From 26608e4edcfafde18ed6c4e876036ff1fb56a50f Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sat, 26 Sep 2015 11:14:54 +0100
Subject: [PATCH 001/113] Initial commit

---
 .gitignore |   2 +
 Cargo.toml |   9 +
 src/lib.rs | 588 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 599 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 Cargo.toml
 create mode 100644 src/lib.rs

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a9d37c5
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+target
+Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..45cf7b2
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "olson-parse"
+version = "0.1.0"
+authors = ["Ben S <ogham@bsago.me>"]
+
+[dependencies]
+datetime = "*"
+lazy_static = "*"
+regex = "*"
\ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..49e9fed
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,588 @@
+//! Parsing Olson DB formats.
+
+#![warn(missing_copy_implementations)]
+#![warn(missing_debug_implementations)]
+#![warn(missing_docs)]
+
+#![warn(trivial_casts, trivial_numeric_casts)]
+#![warn(unused_qualifications)]
+#![warn(unused_results)]
+
+use std::ascii::AsciiExt;
+use std::str::FromStr;
+
+extern crate datetime;
+use datetime::local;
+
+extern crate regex;
+use regex::Regex;
+
+#[macro_use]
+extern crate lazy_static;
+
+
+/// A set of regexes to test against.
+///
+/// All of these regexes use the `(?x)` flag, which means they support
+/// comments and whitespace directly in the regex string!
+lazy_static! {
+
+    /// Format of a Rule line: one capturing group per field.
+    static ref RULE_LINE: Regex = Regex::new(r##"(?x) ^
+        Rule \s+
+        ( ?P<name>    \S+)  \s+
+        ( ?P<from>    \S+)  \s+
+        ( ?P<to>      \S+)  \s+
+        ( ?P<type>    \S+)  \s+
+        ( ?P<in>      \S+)  \s+
+        ( ?P<on>      \S+)  \s+
+        ( ?P<at>      \S+)  \s+
+        ( ?P<save>    \S+)  \s+
+        ( ?P<letters> \S+)
+    $ "##).unwrap();
+
+    /// Format of a Day specification in a Rule.
+    static ref DAY_FIELD: Regex = Regex::new(r##"(?x) ^
+        ( ?P<weekday> \w+ )
+        ( ?P<sign>    [<>] = )
+        ( ?P<day>     \d+ )
+    $ "##).unwrap();
+
+    /// Format of an hour and a minute.
+    static ref HM_FIELD: Regex = Regex::new(r##"(?x) ^
+        ( ?P<hour> \d{1,2} ) : ( ?P<minute> \d{2} )
+        ( ?P<flag> [wsugz] )?
+    $ "##).unwrap();
+
+    /// Format of an hour, a minute, and a second.
+    static ref HMS_FIELD: Regex = Regex::new(r##"(?x) ^
+        ( ?P<hour> \d{1,2} ) : ( ?P<minute> \d{2} ) : ( ?P<second> \d{2} )
+        ( ?P<flag> [wsugz] )?
+    $ "##).unwrap();
+
+    /// Format of a Zone line, with one capturing group per field.
+    static ref ZONE_LINE: Regex = Regex::new(r##"(?x) ^
+        Zone \s+
+        ( ?P<name> [ A-Z a-z / ]+ )  \s+
+        ( ?P<gmtoff>     \S+ )  \s+
+        ( ?P<rulessave>  \S+ )  \s+
+        ( ?P<format>     \S+ )  \s*
+        ( ?P<year>       \S+ )? \s*
+        ( ?P<month>      \S+ )? \s*
+        ( ?P<day>        \S+ )? \s*
+        ( ?P<time>       \S+ )?
+    $ "##).unwrap();
+
+    /// Format of a Link line, with one capturing group per field.
+    static ref LINK_LINE: Regex = Regex::new(r##"(?x) ^
+        Link  \s+
+        ( ?P<target>  \S+ )  \s+
+        ( ?P<name>    \S+ )
+    $ "##).unwrap();
+}
+
+
+/// A **rule** definition line.
+///
+/// According to the `zic` man page, a rule line has the form:
+///
+/// A rule line has the form:
+///
+/// ```text
+///         Rule  NAME  FROM  TO    TYPE  IN   ON       AT    SAVE  LETTER/S
+///    For example:
+///         Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D
+/// ```
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Rule<'line> {
+
+    /// The name of the set of rules that this rule is part of.
+    pub name: &'line str,
+
+    /// The first year in which the rule applies.
+    pub from_year: Year,
+
+    /// The final year, or `None` if's 'only'.
+    pub to_year: Option<Year>,
+
+    /// The month in which the rule takes effect.
+    pub month: Month,
+
+    /// The day on which the rule takes effect.
+    pub day: Day,
+
+    /// The time of day at which the rule takes effect.
+    pub time_of_day: Time,
+
+    /// The amount of time to be added when the rule is in effect.
+    pub time_to_add: Time,
+
+    /// The variable part of time zone abbreviations to be used when this rule
+    /// is in effect, if any.
+    pub letters: Option<&'line str>,
+}
+
+impl<'line> Rule<'line> {
+
+    /// Attempts to parse the given string into a value of this type.
+    fn from_str(input: &str) -> Result<Rule, Error> {
+        if let Some(caps) = RULE_LINE.captures(input) {
+            let name         = caps.name("name").unwrap();
+            let from_year    = try!(caps.name("from").unwrap().parse());
+            let to_year      = match caps.name("to").unwrap() {
+                "only"  => None,
+                to      => Some(try!(to.parse())),
+            };
+
+            // According to the spec, the only value inside the 'type' column
+            // should be "-", so throw an error if it isn't.
+            let t = caps.name("type").unwrap();
+            if t != "-" && t != "\u{2010}"  {
+                return Err(Error::Fail);
+            }
+
+            let month         = try!(caps.name("in").unwrap().parse());
+            let day           = try!(caps.name("on").unwrap().parse());
+            let time_of_day   = try!(caps.name("at").unwrap().parse());
+            let time_to_add   = try!(caps.name("save").unwrap().parse());
+            let letters       = match caps.name("letters").unwrap() {
+                "-"  => None,
+                l    => Some(l),
+            };
+
+            Ok(Rule {
+                name: name,
+                from_year:    from_year,
+                to_year:      to_year,
+                month:        month,
+                day:          day,
+                time_of_day:  time_of_day,
+                time_to_add:  time_to_add,
+                letters:      letters,
+            })
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// A **year** definition field.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Year {
+
+    /// The minimum year possible: `min` or `minimum` in a file.
+    Minimum,
+
+    /// The maximum year possible: `max` or `maximum` in a file.
+    Maximum,
+
+    /// A specific year number.
+    Number(i32),
+}
+
+impl FromStr for Year {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Year, Self::Err> {
+        if input == "min" || input == "minimum" {
+            Ok(Year::Minimum)
+        }
+        else if input == "max" || input == "maximum" {
+            Ok(Year::Maximum)
+        }
+        else if input.chars().all(|c| c.is_digit(10)) {
+            Ok(Year::Number(input.parse().unwrap()))
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// A **month** field, which is actually just a wrapper around
+/// `datetime::local::Month`.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Month(local::Month);
+
+impl FromStr for Month {
+    type Err = Error;
+
+    /// Attempts to parse the given string into a value of this type.
+    fn from_str(input: &str) -> Result<Month, Self::Err> {
+        Ok(match &*input.to_ascii_lowercase() {
+            "jan" | "january"    => Month(local::Month::January),
+            "feb" | "february"   => Month(local::Month::February),
+            "mar" | "march"      => Month(local::Month::March),
+            "apr" | "april"      => Month(local::Month::April),
+            "may"                => Month(local::Month::May),
+            "jun" | "june"       => Month(local::Month::June),
+            "jul" | "july"       => Month(local::Month::July),
+            "aug" | "august"     => Month(local::Month::August),
+            "sep" | "september"  => Month(local::Month::September),
+            "oct" | "october"    => Month(local::Month::October),
+            "nov" | "november"   => Month(local::Month::November),
+            "dec" | "december"   => Month(local::Month::December),
+                  _              => return Err(Error::Fail),
+        })
+    }
+}
+
+
+/// A **weekday** field, which is actually just a wrapper around
+/// `datetime::local::Weekday`.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Weekday(local::Weekday);
+
+impl FromStr for Weekday {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Weekday, Self::Err> {
+
+        Ok(match &*input.to_ascii_lowercase() {
+            "mon" | "monday"     => Weekday(local::Weekday::Monday),
+            "tue" | "tuesday"    => Weekday(local::Weekday::Tuesday),
+            "wed" | "wednesday"  => Weekday(local::Weekday::Wednesday),
+            "thu" | "thursday"   => Weekday(local::Weekday::Thursday),
+            "fri" | "friday"     => Weekday(local::Weekday::Friday),
+            "sat" | "saturday"   => Weekday(local::Weekday::Saturday),
+            "sun" | "sunday"     => Weekday(local::Weekday::Sunday),
+                  _              => return Err(Error::Fail),
+        })
+    }
+}
+
+
+/// A **day** definition field.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Day {
+
+    /// A specific day of the month.
+    Ordinal(i32),
+
+    /// The last day of the month with a specific weekday.
+    Last(Weekday),
+
+    /// The last day **before** a point with a specific weekday.
+    LastOnOrBefore(Weekday, i32),
+
+    /// The last day **after** a point with a specific weekday.
+    LastOnOrAfter(Weekday, i32)
+}
+
+impl FromStr for Day {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Day, Self::Err> {
+        if input.chars().all(|c| c.is_digit(10)) {
+            Ok(Day::Ordinal(input.parse().unwrap()))
+        }
+        else if input.starts_with("last") {
+            let weekday = try!(input[4..].parse());
+            Ok(Day::Last(weekday))
+        }
+        else if let Some(caps) = DAY_FIELD.captures(input) {
+            let weekday = caps.name("weekday").unwrap().parse().unwrap();
+            let day     = caps.name("day").unwrap().parse().unwrap();
+
+            match caps.name("sign").unwrap() {
+                "<" => Ok(Day::LastOnOrBefore(weekday, day)),
+                ">" => Ok(Day::LastOnOrAfter(weekday, day)),
+                 _  => unreachable!("The regex only matches one of those two"),
+            }
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// A **time** definition field.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Time {
+
+    /// A number of hours.
+    Hours(i32),
+
+    /// A number of hours and minutes.
+    HoursMinutes(i32, i32, Option<char>),
+
+    /// A number of hours, minutes, and seconds.
+    HoursMinutesSeconds(i32, i32, i32, Option<char>),
+
+    /// Zero, or midnight at the start of the day.
+    Zero,
+}
+
+impl FromStr for Time {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Time, Self::Err> {
+
+        if input == "-" {
+            Ok(Time::Zero)
+        }
+        else if input.chars().all(|c| c.is_digit(10)) {
+            Ok(Time::Hours(input.parse().unwrap()))
+        }
+        else if let Some(caps) = HM_FIELD.captures(input) {
+            let hour   = caps.name("hour").unwrap().parse().unwrap();
+            let minute = caps.name("minute").unwrap().parse().unwrap();
+            let flag   = caps.name("flag").map(|f| f.chars().next().unwrap());
+            Ok(Time::HoursMinutes(hour, minute, flag))
+        }
+        else if let Some(caps) = HMS_FIELD.captures(input) {
+            let hour   = caps.name("hour").unwrap().parse().unwrap();
+            let minute = caps.name("minute").unwrap().parse().unwrap();
+            let second = caps.name("second").unwrap().parse().unwrap();
+            let flag   = caps.name("flag").map(|f| f.chars().next().unwrap());
+            Ok(Time::HoursMinutesSeconds(hour, minute, second, flag))
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// A **zone** definition line.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Zone<'line> {
+
+    /// The name of the time zone.
+    pub name: &'line str,
+
+    /// The amount of time to be added to Universal Time, to get standard time
+    /// in this zone.
+    pub gmt_offset: Time,
+
+    /// The name of all the rules that should apply in the time zone, or the
+    /// amount of time to add.
+    pub rules_save: RulesSave<'line>,
+
+    /// The format for time zone abbreviations, with `%s` as the string marker.
+    pub format: &'line str,
+
+    /// The time at which the rules change for this location, or `None` if these rules
+    pub time: Option<ZoneTime>,
+}
+
+impl<'line> Zone<'line> {
+    fn from_str(input: &str) -> Result<Zone, Error> {
+        if let Some(caps) = ZONE_LINE.captures(input) {
+            let name          = caps.name("name").unwrap();
+            let gmt_offset    = try!(caps.name("gmtoff").unwrap().parse());
+            let rules_save    = try!(RulesSave::from_str(caps.name("rulessave").unwrap()));
+            let format        = caps.name("format").unwrap();
+
+            let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
+                (Some(y), Some(m), Some(d), Some(t)) => Some(ZoneTime::UntilTime  (try!(y.parse()), try!(m.parse()), try!(d.parse()), try!(t.parse()))),
+                (Some(y), Some(m), Some(d), _      ) => Some(ZoneTime::UntilDay   (try!(y.parse()), try!(m.parse()), try!(d.parse()))),
+                (Some(y), Some(m), _      , _      ) => Some(ZoneTime::UntilMonth (try!(y.parse()), try!(m.parse()))),
+                (Some(y), _      , _      , _      ) => Some(ZoneTime::UntilYear  (try!(y.parse()))),
+                (None   , None   , None   , None   ) => None,
+                _                                    => return Err(Error::Fail),
+            };
+
+            Ok(Zone {
+                name:        name,
+                gmt_offset:  gmt_offset,
+                rules_save:  rules_save,
+                format:      format,
+                time:        time,
+            })
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// A specific type for a certain Zone column.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum RulesSave<'line> {
+
+    /// The name of the **rules** to apply.
+    Rules(&'line str),
+
+    /// The amount of **save** time to add.
+    Save(Time),
+}
+
+impl<'line> RulesSave<'line> {
+    fn from_str(input: &str) -> Result<RulesSave, Error> {
+        if input.chars().all(char::is_alphabetic) {
+            Ok(RulesSave::Rules(input))
+        }
+        else if HM_FIELD.is_match(input) {
+            let time = try!(input.parse());
+            Ok(RulesSave::Save(time))
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// The time at which the rules change for a location, with varying degrees of precision.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum ZoneTime {
+
+    /// The earliest point in a particular **year**.
+    UntilYear(Year),
+
+    /// The earliest point in a particular **month**.
+    UntilMonth(Year, Month),
+
+    /// The earliest point in a particular **day**.
+    UntilDay(Year, Month, Day),
+
+    /// The earliest point in a particular hour, minute, or second, or one of
+    /// those small time units, anyway.
+    UntilTime(Year, Month, Day, Time),
+}
+
+
+/// A **link** definition line.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Link<'line> {
+
+    /// The target time zone, which should appear as the name in a zone definition.
+    existing: &'line str,
+
+    /// Another name that the target can be called.
+    new: &'line str,
+}
+
+impl<'line> Link<'line> {
+    fn from_str(input: &str) -> Result<Link, Error> {
+        if let Some(caps) = LINK_LINE.captures(input) {
+            let target  = caps.name("target").unwrap();
+            let name    = caps.name("name").unwrap();
+            Ok(Link { existing: target, new: name })
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// An error that can occur during parsing.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Error {
+
+    /// TODO: more error types
+    Fail
+}
+
+/// A type of valid line that has been parsed.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Line<'line> {
+
+    /// This line is a comment.
+    Comment,
+
+    /// This line is empty.
+    Space,
+
+    /// This line contains a **zone** definition.
+    Zone(Zone<'line>),
+
+    /// This line contains a **rule** definition.
+    Rule(Rule<'line>),
+
+    /// This line contains a **link** definition.
+    Link(Link<'line>),
+}
+
+impl<'line> Line<'line> {
+
+    /// Attempts to parse the given string into a value of this type.
+    pub fn from_str(input: &str) -> Result<Line, Error> {
+        if input.starts_with("#") {
+            Ok(Line::Comment)
+        }
+        else if input.is_empty() {
+            Ok(Line::Space)
+        }
+        else if let Ok(zone) = Zone::from_str(input) {
+            Ok(Line::Zone(zone))
+        }
+        else if let Ok(rule) = Rule::from_str(input) {
+            Ok(Line::Rule(rule))
+        }
+        else if let Ok(link) = Link::from_str(input) {
+            Ok(Line::Link(link))
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+#[cfg(test)]
+mod test {
+    use std::str::FromStr;
+
+    use super::*;
+    use datetime::local;
+
+    macro_rules! test {
+        ($name:ident: $input:expr => $result:expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!(Line::from_str($input), Ok($result));
+            }
+        };
+    }
+
+    test!(comment:  "# comment"  => Line::Comment);
+    test!(empty:    ""           => Line::Space);
+
+    test!(example: "Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D" => Line::Rule(Rule {
+        name:         "US",
+        from_year:    Year::Number(1967),
+        to_year:      Some(Year::Number(1973)),
+        month:        Month(local::Month::April),
+        day:          Day::Last(Weekday(local::Weekday::Sunday)),
+        time_of_day:  Time::HoursMinutes(2, 0, None),
+        time_to_add:  Time::HoursMinutes(1, 0, None),
+        letters:      Some("D"),
+    }));
+
+    test!(example_2: "Rule	Greece	1976	only	-	Oct	10	2:00s	0	-" => Line::Rule(Rule {
+        name:         "Greece",
+        from_year:    Year::Number(1976),
+        to_year:      None,
+        month:        Month(local::Month::October),
+        day:          Day::Ordinal(10),
+        time_of_day:  Time::HoursMinutes(2, 0, Some('s')),
+        time_to_add:  Time::Hours(0),
+        letters:      None,
+    }));
+
+    test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00" => Line::Zone(Zone {
+        name:        "Australia/Adelaide",
+        gmt_offset:  Time::HoursMinutes(9, 30, None),
+        rules_save:  RulesSave::Rules("Aus"),
+        format:      "AC%sT",
+        time:        Some(ZoneTime::UntilTime(Year::Number(1971), Month(local::Month::October), Day::Ordinal(31), Time::HoursMinutes(2, 0, None))),
+    }));
+
+    test!(link: "Link  Europe/Istanbul  Asia/Istanbul" => Line::Link(Link {
+        existing:  "Europe/Istanbul",
+        new:       "Asia/Istanbul",
+    }));
+
+    #[test]
+    fn month() {
+        assert_eq!(Month::from_str("Aug"), Ok(Month(local::Month::August)));
+    }
+}

From 78d70de784ba94f820c11b841437873f8eeac844 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sat, 26 Sep 2015 11:34:49 +0100
Subject: [PATCH 002/113] Add Travis integ.

---
 .travis.yml | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 .travis.yml

diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..2b2d239
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,30 @@
+language: rust
+sudo: required
+rust:
+  - nightly
+  - beta
+  - stable
+
+addons:
+  apt:
+    packages:
+      - libcurl4-openssl-dev
+      - libelf-dev
+      - libdw-dev
+
+before_script:
+  - |
+      pip install 'travis-cargo<0.2' --user &&
+      export PATH=$HOME/.local/bin:$PATH
+
+script:
+  - |
+      travis-cargo build &&
+      travis-cargo test
+
+after_success:
+  - travis-cargo coveralls --no-sudo
+
+env:
+  global:
+    - TRAVIS_CARGO_NIGHTLY_FEATURE=""

From 0fcafc8d4719ece20c89ec53eb00bcd0696b015a Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sat, 26 Sep 2015 19:56:32 +0100
Subject: [PATCH 003/113] Fix bug a test found

The equals signs are included in the day-of-transition capture sign.
---
 src/lib.rs | 27 ++++++++++++++++++++++-----
 1 file changed, 22 insertions(+), 5 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 49e9fed..1bdf8ad 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -288,9 +288,9 @@ impl FromStr for Day {
             let day     = caps.name("day").unwrap().parse().unwrap();
 
             match caps.name("sign").unwrap() {
-                "<" => Ok(Day::LastOnOrBefore(weekday, day)),
-                ">" => Ok(Day::LastOnOrAfter(weekday, day)),
-                 _  => unreachable!("The regex only matches one of those two"),
+                "<=" => Ok(Day::LastOnOrBefore(weekday, day)),
+                ">=" => Ok(Day::LastOnOrAfter(weekday, day)),
+                 _   => unreachable!("The regex only matches one of those two"),
             }
         }
         else {
@@ -568,12 +568,23 @@ mod test {
         letters:      None,
     }));
 
-    test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00" => Line::Zone(Zone {
+    test!(rule_3: "Rule	EU	1977	1980	-	Apr	Sun>=1	 1:00u	1:00	S" => Line::Rule(Rule {
+        name: "EU",
+        from_year: Year::Number(1977),
+        to_year: Some(Year::Number(1980)),
+        month: Month(local::Month::April),
+        day: Day::LastOnOrAfter(Weekday(local::Weekday::Sunday), 1),
+        time_of_day: Time::HoursMinutes(1, 0, Some('u')),
+        time_to_add: Time::HoursMinutes(1, 0, None),
+        letters:     Some("S"),
+    }));
+
+    test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Line::Zone(Zone {
         name:        "Australia/Adelaide",
         gmt_offset:  Time::HoursMinutes(9, 30, None),
         rules_save:  RulesSave::Rules("Aus"),
         format:      "AC%sT",
-        time:        Some(ZoneTime::UntilTime(Year::Number(1971), Month(local::Month::October), Day::Ordinal(31), Time::HoursMinutes(2, 0, None))),
+        time:        Some(ZoneTime::UntilTime(Year::Number(1971), Month(local::Month::October), Day::Ordinal(31), Time::HoursMinutesSeconds(2, 0, 0, None))),
     }));
 
     test!(link: "Link  Europe/Istanbul  Asia/Istanbul" => Line::Link(Link {
@@ -584,5 +595,11 @@ mod test {
     #[test]
     fn month() {
         assert_eq!(Month::from_str("Aug"), Ok(Month(local::Month::August)));
+        assert_eq!(Month::from_str("December"), Ok(Month(local::Month::December)));
+    }
+
+    #[test]
+    fn golb() {
+        assert!(Line::from_str("GOLB").is_err());
     }
 }

From 16085793834dcb025c2ecca56bc71bb3eaf65fc3 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sun, 27 Sep 2015 12:04:25 +0100
Subject: [PATCH 004/113] Tests and bug fixes

---
 src/lib.rs | 136 +++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 100 insertions(+), 36 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 1bdf8ad..9b14597 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -15,7 +15,7 @@ extern crate datetime;
 use datetime::local;
 
 extern crate regex;
-use regex::Regex;
+use regex::{Regex, Captures};
 
 #[macro_use]
 extern crate lazy_static;
@@ -39,7 +39,7 @@ lazy_static! {
         ( ?P<at>      \S+)  \s+
         ( ?P<save>    \S+)  \s+
         ( ?P<letters> \S+)
-    $ "##).unwrap();
+    "##).unwrap();
 
     /// Format of a Day specification in a Rule.
     static ref DAY_FIELD: Regex = Regex::new(r##"(?x) ^
@@ -50,20 +50,20 @@ lazy_static! {
 
     /// Format of an hour and a minute.
     static ref HM_FIELD: Regex = Regex::new(r##"(?x) ^
-        ( ?P<hour> \d{1,2} ) : ( ?P<minute> \d{2} )
+        ( ?P<hour> -? \d{1,2} ) : ( ?P<minute> \d{2} )
         ( ?P<flag> [wsugz] )?
     $ "##).unwrap();
 
     /// Format of an hour, a minute, and a second.
     static ref HMS_FIELD: Regex = Regex::new(r##"(?x) ^
-        ( ?P<hour> \d{1,2} ) : ( ?P<minute> \d{2} ) : ( ?P<second> \d{2} )
+        ( ?P<hour> -? \d{1,2} ) : ( ?P<minute> \d{2} ) : ( ?P<second> \d{2} )
         ( ?P<flag> [wsugz] )?
     $ "##).unwrap();
 
     /// Format of a Zone line, with one capturing group per field.
     static ref ZONE_LINE: Regex = Regex::new(r##"(?x) ^
         Zone \s+
-        ( ?P<name> [ A-Z a-z / ]+ )  \s+
+        ( ?P<name> [ A-Z a-z 0-9 / _ + - ]+ )  \s+
         ( ?P<gmtoff>     \S+ )  \s+
         ( ?P<rulessave>  \S+ )  \s+
         ( ?P<format>     \S+ )  \s*
@@ -71,14 +71,27 @@ lazy_static! {
         ( ?P<month>      \S+ )? \s*
         ( ?P<day>        \S+ )? \s*
         ( ?P<time>       \S+ )?
-    $ "##).unwrap();
+    "##).unwrap();
+
+    /// Format of a Continuation Zone line, which is the same as the opening
+    /// Zone line except the first two fields are replaced by whitespace.
+    static ref CONTINUATION_LINE: Regex = Regex::new(r##"(?x) ^
+        \s+
+        ( ?P<gmtoff>     \S+ )  \s+
+        ( ?P<rulessave>  \S+ )  \s+
+        ( ?P<format>     \S+ )  \s*
+        ( ?P<year>       \S+ )? \s*
+        ( ?P<month>      \S+ )? \s*
+        ( ?P<day>        \S+ )? \s*
+        ( ?P<time>       \S+ )?
+    "##).unwrap();
 
     /// Format of a Link line, with one capturing group per field.
     static ref LINK_LINE: Regex = Regex::new(r##"(?x) ^
         Link  \s+
         ( ?P<target>  \S+ )  \s+
         ( ?P<name>    \S+ )
-    $ "##).unwrap();
+    "##).unwrap();
 }
 
 
@@ -325,7 +338,7 @@ impl FromStr for Time {
         if input == "-" {
             Ok(Time::Zero)
         }
-        else if input.chars().all(|c| c.is_digit(10)) {
+        else if input.chars().all(|c| c == '-' || c.is_digit(10)) {
             Ok(Time::Hours(input.parse().unwrap()))
         }
         else if let Some(caps) = HM_FIELD.captures(input) {
@@ -355,6 +368,14 @@ pub struct Zone<'line> {
     /// The name of the time zone.
     pub name: &'line str,
 
+    /// All the other fields of info.
+    pub info: ZoneInfo<'line>,
+}
+
+/// The information contained in both zone lines and zone continuation lines.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct ZoneInfo<'line> {
+
     /// The amount of time to be added to Universal Time, to get standard time
     /// in this zone.
     pub gmt_offset: Time,
@@ -373,26 +394,12 @@ pub struct Zone<'line> {
 impl<'line> Zone<'line> {
     fn from_str(input: &str) -> Result<Zone, Error> {
         if let Some(caps) = ZONE_LINE.captures(input) {
-            let name          = caps.name("name").unwrap();
-            let gmt_offset    = try!(caps.name("gmtoff").unwrap().parse());
-            let rules_save    = try!(RulesSave::from_str(caps.name("rulessave").unwrap()));
-            let format        = caps.name("format").unwrap();
-
-            let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
-                (Some(y), Some(m), Some(d), Some(t)) => Some(ZoneTime::UntilTime  (try!(y.parse()), try!(m.parse()), try!(d.parse()), try!(t.parse()))),
-                (Some(y), Some(m), Some(d), _      ) => Some(ZoneTime::UntilDay   (try!(y.parse()), try!(m.parse()), try!(d.parse()))),
-                (Some(y), Some(m), _      , _      ) => Some(ZoneTime::UntilMonth (try!(y.parse()), try!(m.parse()))),
-                (Some(y), _      , _      , _      ) => Some(ZoneTime::UntilYear  (try!(y.parse()))),
-                (None   , None   , None   , None   ) => None,
-                _                                    => return Err(Error::Fail),
-            };
+            let name = caps.name("name").unwrap();
+            let info = try!(ZoneInfo::from_captures(caps));
 
             Ok(Zone {
-                name:        name,
-                gmt_offset:  gmt_offset,
-                rules_save:  rules_save,
-                format:      format,
-                time:        time,
+                name: name,
+                info: info,
             })
         }
         else {
@@ -401,6 +408,30 @@ impl<'line> Zone<'line> {
     }
 }
 
+impl<'line> ZoneInfo<'line> {
+    fn from_captures(caps: Captures<'line>) -> Result<ZoneInfo<'line>, Error> {
+        let gmt_offset    = try!(caps.name("gmtoff").unwrap().parse());
+        let rules_save    = try!(RulesSave::from_str(caps.name("rulessave").unwrap()));
+        let format        = caps.name("format").unwrap();
+
+        let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
+            (Some(y), Some(m), Some(d), Some(t)) => Some(ZoneTime::UntilTime  (try!(y.parse()), try!(m.parse()), try!(d.parse()), try!(t.parse()))),
+            (Some(y), Some(m), Some(d), _      ) => Some(ZoneTime::UntilDay   (try!(y.parse()), try!(m.parse()), try!(d.parse()))),
+            (Some(y), Some(m), _      , _      ) => Some(ZoneTime::UntilMonth (try!(y.parse()), try!(m.parse()))),
+            (Some(y), _      , _      , _      ) => Some(ZoneTime::UntilYear  (try!(y.parse()))),
+            (None   , None   , None   , None   ) => None,
+            _                                    => return Err(Error::Fail),
+        };
+
+        Ok(ZoneInfo {
+            gmt_offset:  gmt_offset,
+            rules_save:  rules_save,
+            format:      format,
+            time:        time,
+        })
+    }
+}
+
 
 /// A specific type for a certain Zone column.
 #[derive(PartialEq, Debug, Copy, Clone)]
@@ -411,11 +442,17 @@ pub enum RulesSave<'line> {
 
     /// The amount of **save** time to add.
     Save(Time),
+
+    /// Neither of these were specified.
+    Neither,
 }
 
 impl<'line> RulesSave<'line> {
     fn from_str(input: &str) -> Result<RulesSave, Error> {
-        if input.chars().all(char::is_alphabetic) {
+        if input == "-" {
+            Ok(RulesSave::Neither)
+        }
+        else if input.chars().all(|c| c == '-' || c == '_' || c.is_alphabetic()) {
             Ok(RulesSave::Rules(input))
         }
         else if HM_FIELD.is_match(input) {
@@ -485,15 +522,15 @@ pub enum Error {
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub enum Line<'line> {
 
-    /// This line is a comment.
-    Comment,
-
     /// This line is empty.
     Space,
 
     /// This line contains a **zone** definition.
     Zone(Zone<'line>),
 
+    /// This line contains a **continuation** of a zone definition.
+    Continuation(ZoneInfo<'line>),
+
     /// This line contains a **rule** definition.
     Rule(Rule<'line>),
 
@@ -505,15 +542,15 @@ impl<'line> Line<'line> {
 
     /// Attempts to parse the given string into a value of this type.
     pub fn from_str(input: &str) -> Result<Line, Error> {
-        if input.starts_with("#") {
-            Ok(Line::Comment)
-        }
-        else if input.is_empty() {
+        if input.is_empty() || input.chars().all(char::is_whitespace) {
             Ok(Line::Space)
         }
         else if let Ok(zone) = Zone::from_str(input) {
             Ok(Line::Zone(zone))
         }
+        else if let Some(caps) = CONTINUATION_LINE.captures(input) {
+            Ok(Line::Continuation(try!(ZoneInfo::from_captures(caps))))
+        }
         else if let Ok(rule) = Rule::from_str(input) {
             Ok(Line::Rule(rule))
         }
@@ -543,7 +580,6 @@ mod test {
         };
     }
 
-    test!(comment:  "# comment"  => Line::Comment);
     test!(empty:    ""           => Line::Space);
 
     test!(example: "Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D" => Line::Rule(Rule {
@@ -580,7 +616,16 @@ mod test {
     }));
 
     test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Line::Zone(Zone {
-        name:        "Australia/Adelaide",
+        name: "Australia/Adelaide",
+        info: ZoneInfo {
+            gmt_offset:  Time::HoursMinutes(9, 30, None),
+            rules_save:  RulesSave::Rules("Aus"),
+            format:      "AC%sT",
+            time:        Some(ZoneTime::UntilTime(Year::Number(1971), Month(local::Month::October), Day::Ordinal(31), Time::HoursMinutesSeconds(2, 0, 0, None))),
+        },
+    }));
+
+    test!(continuation: "                          9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Line::Continuation(ZoneInfo {
         gmt_offset:  Time::HoursMinutes(9, 30, None),
         rules_save:  RulesSave::Rules("Aus"),
         format:      "AC%sT",
@@ -592,6 +637,25 @@ mod test {
         new:       "Asia/Istanbul",
     }));
 
+    test!(continuatio2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Line::Continuation(ZoneInfo {
+        gmt_offset:  Time::HoursMinutes(1, 00, None),
+        rules_save:  RulesSave::Rules("C-Eur"),
+        format:      "CE%sT",
+        time:        Some(ZoneTime::UntilDay(Year::Number(1943), Month(local::Month::October), Day::Ordinal(25))),
+    }));
+
+    test!(zone_hyphen: "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919" => Line::Zone(Zone {
+        name: "Asia/Ust-Nera",
+        info: ZoneInfo {
+            gmt_offset:  Time::HoursMinutesSeconds(9, 32, 54, None),
+            rules_save:  RulesSave::Neither,
+            format:      "LMT",
+            time:        Some(ZoneTime::UntilYear(Year::Number(1919))),
+        },
+    }));
+
+    /// "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919 Dec 15"
+
     #[test]
     fn month() {
         assert_eq!(Month::from_str("Aug"), Ok(Month(local::Month::August)));

From b14517547745e6a8e3708f350c45732b18846cc1 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sun, 27 Sep 2015 12:31:53 +0100
Subject: [PATCH 005/113] Move line parsing to its own module

---
 src/lib.rs  | 660 +---------------------------------------------------
 src/line.rs | 654 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 657 insertions(+), 657 deletions(-)
 create mode 100644 src/line.rs

diff --git a/src/lib.rs b/src/lib.rs
index 9b14597..737f2a0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,667 +3,13 @@
 #![warn(missing_copy_implementations)]
 #![warn(missing_debug_implementations)]
 #![warn(missing_docs)]
-
 #![warn(trivial_casts, trivial_numeric_casts)]
 #![warn(unused_qualifications)]
 #![warn(unused_results)]
 
-use std::ascii::AsciiExt;
-use std::str::FromStr;
-
 extern crate datetime;
-use datetime::local;
-
 extern crate regex;
-use regex::{Regex, Captures};
-
-#[macro_use]
-extern crate lazy_static;
-
-
-/// A set of regexes to test against.
-///
-/// All of these regexes use the `(?x)` flag, which means they support
-/// comments and whitespace directly in the regex string!
-lazy_static! {
-
-    /// Format of a Rule line: one capturing group per field.
-    static ref RULE_LINE: Regex = Regex::new(r##"(?x) ^
-        Rule \s+
-        ( ?P<name>    \S+)  \s+
-        ( ?P<from>    \S+)  \s+
-        ( ?P<to>      \S+)  \s+
-        ( ?P<type>    \S+)  \s+
-        ( ?P<in>      \S+)  \s+
-        ( ?P<on>      \S+)  \s+
-        ( ?P<at>      \S+)  \s+
-        ( ?P<save>    \S+)  \s+
-        ( ?P<letters> \S+)
-    "##).unwrap();
-
-    /// Format of a Day specification in a Rule.
-    static ref DAY_FIELD: Regex = Regex::new(r##"(?x) ^
-        ( ?P<weekday> \w+ )
-        ( ?P<sign>    [<>] = )
-        ( ?P<day>     \d+ )
-    $ "##).unwrap();
-
-    /// Format of an hour and a minute.
-    static ref HM_FIELD: Regex = Regex::new(r##"(?x) ^
-        ( ?P<hour> -? \d{1,2} ) : ( ?P<minute> \d{2} )
-        ( ?P<flag> [wsugz] )?
-    $ "##).unwrap();
-
-    /// Format of an hour, a minute, and a second.
-    static ref HMS_FIELD: Regex = Regex::new(r##"(?x) ^
-        ( ?P<hour> -? \d{1,2} ) : ( ?P<minute> \d{2} ) : ( ?P<second> \d{2} )
-        ( ?P<flag> [wsugz] )?
-    $ "##).unwrap();
-
-    /// Format of a Zone line, with one capturing group per field.
-    static ref ZONE_LINE: Regex = Regex::new(r##"(?x) ^
-        Zone \s+
-        ( ?P<name> [ A-Z a-z 0-9 / _ + - ]+ )  \s+
-        ( ?P<gmtoff>     \S+ )  \s+
-        ( ?P<rulessave>  \S+ )  \s+
-        ( ?P<format>     \S+ )  \s*
-        ( ?P<year>       \S+ )? \s*
-        ( ?P<month>      \S+ )? \s*
-        ( ?P<day>        \S+ )? \s*
-        ( ?P<time>       \S+ )?
-    "##).unwrap();
-
-    /// Format of a Continuation Zone line, which is the same as the opening
-    /// Zone line except the first two fields are replaced by whitespace.
-    static ref CONTINUATION_LINE: Regex = Regex::new(r##"(?x) ^
-        \s+
-        ( ?P<gmtoff>     \S+ )  \s+
-        ( ?P<rulessave>  \S+ )  \s+
-        ( ?P<format>     \S+ )  \s*
-        ( ?P<year>       \S+ )? \s*
-        ( ?P<month>      \S+ )? \s*
-        ( ?P<day>        \S+ )? \s*
-        ( ?P<time>       \S+ )?
-    "##).unwrap();
-
-    /// Format of a Link line, with one capturing group per field.
-    static ref LINK_LINE: Regex = Regex::new(r##"(?x) ^
-        Link  \s+
-        ( ?P<target>  \S+ )  \s+
-        ( ?P<name>    \S+ )
-    "##).unwrap();
-}
-
-
-/// A **rule** definition line.
-///
-/// According to the `zic` man page, a rule line has the form:
-///
-/// A rule line has the form:
-///
-/// ```text
-///         Rule  NAME  FROM  TO    TYPE  IN   ON       AT    SAVE  LETTER/S
-///    For example:
-///         Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D
-/// ```
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct Rule<'line> {
-
-    /// The name of the set of rules that this rule is part of.
-    pub name: &'line str,
-
-    /// The first year in which the rule applies.
-    pub from_year: Year,
-
-    /// The final year, or `None` if's 'only'.
-    pub to_year: Option<Year>,
-
-    /// The month in which the rule takes effect.
-    pub month: Month,
-
-    /// The day on which the rule takes effect.
-    pub day: Day,
-
-    /// The time of day at which the rule takes effect.
-    pub time_of_day: Time,
-
-    /// The amount of time to be added when the rule is in effect.
-    pub time_to_add: Time,
-
-    /// The variable part of time zone abbreviations to be used when this rule
-    /// is in effect, if any.
-    pub letters: Option<&'line str>,
-}
-
-impl<'line> Rule<'line> {
-
-    /// Attempts to parse the given string into a value of this type.
-    fn from_str(input: &str) -> Result<Rule, Error> {
-        if let Some(caps) = RULE_LINE.captures(input) {
-            let name         = caps.name("name").unwrap();
-            let from_year    = try!(caps.name("from").unwrap().parse());
-            let to_year      = match caps.name("to").unwrap() {
-                "only"  => None,
-                to      => Some(try!(to.parse())),
-            };
-
-            // According to the spec, the only value inside the 'type' column
-            // should be "-", so throw an error if it isn't.
-            let t = caps.name("type").unwrap();
-            if t != "-" && t != "\u{2010}"  {
-                return Err(Error::Fail);
-            }
-
-            let month         = try!(caps.name("in").unwrap().parse());
-            let day           = try!(caps.name("on").unwrap().parse());
-            let time_of_day   = try!(caps.name("at").unwrap().parse());
-            let time_to_add   = try!(caps.name("save").unwrap().parse());
-            let letters       = match caps.name("letters").unwrap() {
-                "-"  => None,
-                l    => Some(l),
-            };
-
-            Ok(Rule {
-                name: name,
-                from_year:    from_year,
-                to_year:      to_year,
-                month:        month,
-                day:          day,
-                time_of_day:  time_of_day,
-                time_to_add:  time_to_add,
-                letters:      letters,
-            })
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-
-/// A **year** definition field.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum Year {
-
-    /// The minimum year possible: `min` or `minimum` in a file.
-    Minimum,
-
-    /// The maximum year possible: `max` or `maximum` in a file.
-    Maximum,
-
-    /// A specific year number.
-    Number(i32),
-}
-
-impl FromStr for Year {
-    type Err = Error;
-
-    fn from_str(input: &str) -> Result<Year, Self::Err> {
-        if input == "min" || input == "minimum" {
-            Ok(Year::Minimum)
-        }
-        else if input == "max" || input == "maximum" {
-            Ok(Year::Maximum)
-        }
-        else if input.chars().all(|c| c.is_digit(10)) {
-            Ok(Year::Number(input.parse().unwrap()))
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-
-/// A **month** field, which is actually just a wrapper around
-/// `datetime::local::Month`.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct Month(local::Month);
-
-impl FromStr for Month {
-    type Err = Error;
-
-    /// Attempts to parse the given string into a value of this type.
-    fn from_str(input: &str) -> Result<Month, Self::Err> {
-        Ok(match &*input.to_ascii_lowercase() {
-            "jan" | "january"    => Month(local::Month::January),
-            "feb" | "february"   => Month(local::Month::February),
-            "mar" | "march"      => Month(local::Month::March),
-            "apr" | "april"      => Month(local::Month::April),
-            "may"                => Month(local::Month::May),
-            "jun" | "june"       => Month(local::Month::June),
-            "jul" | "july"       => Month(local::Month::July),
-            "aug" | "august"     => Month(local::Month::August),
-            "sep" | "september"  => Month(local::Month::September),
-            "oct" | "october"    => Month(local::Month::October),
-            "nov" | "november"   => Month(local::Month::November),
-            "dec" | "december"   => Month(local::Month::December),
-                  _              => return Err(Error::Fail),
-        })
-    }
-}
-
-
-/// A **weekday** field, which is actually just a wrapper around
-/// `datetime::local::Weekday`.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct Weekday(local::Weekday);
-
-impl FromStr for Weekday {
-    type Err = Error;
-
-    fn from_str(input: &str) -> Result<Weekday, Self::Err> {
-
-        Ok(match &*input.to_ascii_lowercase() {
-            "mon" | "monday"     => Weekday(local::Weekday::Monday),
-            "tue" | "tuesday"    => Weekday(local::Weekday::Tuesday),
-            "wed" | "wednesday"  => Weekday(local::Weekday::Wednesday),
-            "thu" | "thursday"   => Weekday(local::Weekday::Thursday),
-            "fri" | "friday"     => Weekday(local::Weekday::Friday),
-            "sat" | "saturday"   => Weekday(local::Weekday::Saturday),
-            "sun" | "sunday"     => Weekday(local::Weekday::Sunday),
-                  _              => return Err(Error::Fail),
-        })
-    }
-}
-
-
-/// A **day** definition field.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum Day {
-
-    /// A specific day of the month.
-    Ordinal(i32),
-
-    /// The last day of the month with a specific weekday.
-    Last(Weekday),
-
-    /// The last day **before** a point with a specific weekday.
-    LastOnOrBefore(Weekday, i32),
-
-    /// The last day **after** a point with a specific weekday.
-    LastOnOrAfter(Weekday, i32)
-}
-
-impl FromStr for Day {
-    type Err = Error;
-
-    fn from_str(input: &str) -> Result<Day, Self::Err> {
-        if input.chars().all(|c| c.is_digit(10)) {
-            Ok(Day::Ordinal(input.parse().unwrap()))
-        }
-        else if input.starts_with("last") {
-            let weekday = try!(input[4..].parse());
-            Ok(Day::Last(weekday))
-        }
-        else if let Some(caps) = DAY_FIELD.captures(input) {
-            let weekday = caps.name("weekday").unwrap().parse().unwrap();
-            let day     = caps.name("day").unwrap().parse().unwrap();
-
-            match caps.name("sign").unwrap() {
-                "<=" => Ok(Day::LastOnOrBefore(weekday, day)),
-                ">=" => Ok(Day::LastOnOrAfter(weekday, day)),
-                 _   => unreachable!("The regex only matches one of those two"),
-            }
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-
-/// A **time** definition field.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum Time {
-
-    /// A number of hours.
-    Hours(i32),
-
-    /// A number of hours and minutes.
-    HoursMinutes(i32, i32, Option<char>),
-
-    /// A number of hours, minutes, and seconds.
-    HoursMinutesSeconds(i32, i32, i32, Option<char>),
-
-    /// Zero, or midnight at the start of the day.
-    Zero,
-}
-
-impl FromStr for Time {
-    type Err = Error;
-
-    fn from_str(input: &str) -> Result<Time, Self::Err> {
-
-        if input == "-" {
-            Ok(Time::Zero)
-        }
-        else if input.chars().all(|c| c == '-' || c.is_digit(10)) {
-            Ok(Time::Hours(input.parse().unwrap()))
-        }
-        else if let Some(caps) = HM_FIELD.captures(input) {
-            let hour   = caps.name("hour").unwrap().parse().unwrap();
-            let minute = caps.name("minute").unwrap().parse().unwrap();
-            let flag   = caps.name("flag").map(|f| f.chars().next().unwrap());
-            Ok(Time::HoursMinutes(hour, minute, flag))
-        }
-        else if let Some(caps) = HMS_FIELD.captures(input) {
-            let hour   = caps.name("hour").unwrap().parse().unwrap();
-            let minute = caps.name("minute").unwrap().parse().unwrap();
-            let second = caps.name("second").unwrap().parse().unwrap();
-            let flag   = caps.name("flag").map(|f| f.chars().next().unwrap());
-            Ok(Time::HoursMinutesSeconds(hour, minute, second, flag))
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-
-/// A **zone** definition line.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct Zone<'line> {
-
-    /// The name of the time zone.
-    pub name: &'line str,
-
-    /// All the other fields of info.
-    pub info: ZoneInfo<'line>,
-}
-
-/// The information contained in both zone lines and zone continuation lines.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct ZoneInfo<'line> {
-
-    /// The amount of time to be added to Universal Time, to get standard time
-    /// in this zone.
-    pub gmt_offset: Time,
-
-    /// The name of all the rules that should apply in the time zone, or the
-    /// amount of time to add.
-    pub rules_save: RulesSave<'line>,
-
-    /// The format for time zone abbreviations, with `%s` as the string marker.
-    pub format: &'line str,
-
-    /// The time at which the rules change for this location, or `None` if these rules
-    pub time: Option<ZoneTime>,
-}
-
-impl<'line> Zone<'line> {
-    fn from_str(input: &str) -> Result<Zone, Error> {
-        if let Some(caps) = ZONE_LINE.captures(input) {
-            let name = caps.name("name").unwrap();
-            let info = try!(ZoneInfo::from_captures(caps));
-
-            Ok(Zone {
-                name: name,
-                info: info,
-            })
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-impl<'line> ZoneInfo<'line> {
-    fn from_captures(caps: Captures<'line>) -> Result<ZoneInfo<'line>, Error> {
-        let gmt_offset    = try!(caps.name("gmtoff").unwrap().parse());
-        let rules_save    = try!(RulesSave::from_str(caps.name("rulessave").unwrap()));
-        let format        = caps.name("format").unwrap();
-
-        let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
-            (Some(y), Some(m), Some(d), Some(t)) => Some(ZoneTime::UntilTime  (try!(y.parse()), try!(m.parse()), try!(d.parse()), try!(t.parse()))),
-            (Some(y), Some(m), Some(d), _      ) => Some(ZoneTime::UntilDay   (try!(y.parse()), try!(m.parse()), try!(d.parse()))),
-            (Some(y), Some(m), _      , _      ) => Some(ZoneTime::UntilMonth (try!(y.parse()), try!(m.parse()))),
-            (Some(y), _      , _      , _      ) => Some(ZoneTime::UntilYear  (try!(y.parse()))),
-            (None   , None   , None   , None   ) => None,
-            _                                    => return Err(Error::Fail),
-        };
-
-        Ok(ZoneInfo {
-            gmt_offset:  gmt_offset,
-            rules_save:  rules_save,
-            format:      format,
-            time:        time,
-        })
-    }
-}
-
-
-/// A specific type for a certain Zone column.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum RulesSave<'line> {
-
-    /// The name of the **rules** to apply.
-    Rules(&'line str),
-
-    /// The amount of **save** time to add.
-    Save(Time),
-
-    /// Neither of these were specified.
-    Neither,
-}
-
-impl<'line> RulesSave<'line> {
-    fn from_str(input: &str) -> Result<RulesSave, Error> {
-        if input == "-" {
-            Ok(RulesSave::Neither)
-        }
-        else if input.chars().all(|c| c == '-' || c == '_' || c.is_alphabetic()) {
-            Ok(RulesSave::Rules(input))
-        }
-        else if HM_FIELD.is_match(input) {
-            let time = try!(input.parse());
-            Ok(RulesSave::Save(time))
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-
-/// The time at which the rules change for a location, with varying degrees of precision.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum ZoneTime {
-
-    /// The earliest point in a particular **year**.
-    UntilYear(Year),
-
-    /// The earliest point in a particular **month**.
-    UntilMonth(Year, Month),
-
-    /// The earliest point in a particular **day**.
-    UntilDay(Year, Month, Day),
-
-    /// The earliest point in a particular hour, minute, or second, or one of
-    /// those small time units, anyway.
-    UntilTime(Year, Month, Day, Time),
-}
-
-
-/// A **link** definition line.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct Link<'line> {
-
-    /// The target time zone, which should appear as the name in a zone definition.
-    existing: &'line str,
-
-    /// Another name that the target can be called.
-    new: &'line str,
-}
-
-impl<'line> Link<'line> {
-    fn from_str(input: &str) -> Result<Link, Error> {
-        if let Some(caps) = LINK_LINE.captures(input) {
-            let target  = caps.name("target").unwrap();
-            let name    = caps.name("name").unwrap();
-            Ok(Link { existing: target, new: name })
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-
-/// An error that can occur during parsing.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum Error {
-
-    /// TODO: more error types
-    Fail
-}
-
-/// A type of valid line that has been parsed.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum Line<'line> {
-
-    /// This line is empty.
-    Space,
-
-    /// This line contains a **zone** definition.
-    Zone(Zone<'line>),
-
-    /// This line contains a **continuation** of a zone definition.
-    Continuation(ZoneInfo<'line>),
-
-    /// This line contains a **rule** definition.
-    Rule(Rule<'line>),
-
-    /// This line contains a **link** definition.
-    Link(Link<'line>),
-}
-
-impl<'line> Line<'line> {
-
-    /// Attempts to parse the given string into a value of this type.
-    pub fn from_str(input: &str) -> Result<Line, Error> {
-        if input.is_empty() || input.chars().all(char::is_whitespace) {
-            Ok(Line::Space)
-        }
-        else if let Ok(zone) = Zone::from_str(input) {
-            Ok(Line::Zone(zone))
-        }
-        else if let Some(caps) = CONTINUATION_LINE.captures(input) {
-            Ok(Line::Continuation(try!(ZoneInfo::from_captures(caps))))
-        }
-        else if let Ok(rule) = Rule::from_str(input) {
-            Ok(Line::Rule(rule))
-        }
-        else if let Ok(link) = Link::from_str(input) {
-            Ok(Line::Link(link))
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-
-#[cfg(test)]
-mod test {
-    use std::str::FromStr;
-
-    use super::*;
-    use datetime::local;
-
-    macro_rules! test {
-        ($name:ident: $input:expr => $result:expr) => {
-            #[test]
-            fn $name() {
-                assert_eq!(Line::from_str($input), Ok($result));
-            }
-        };
-    }
-
-    test!(empty:    ""           => Line::Space);
-
-    test!(example: "Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D" => Line::Rule(Rule {
-        name:         "US",
-        from_year:    Year::Number(1967),
-        to_year:      Some(Year::Number(1973)),
-        month:        Month(local::Month::April),
-        day:          Day::Last(Weekday(local::Weekday::Sunday)),
-        time_of_day:  Time::HoursMinutes(2, 0, None),
-        time_to_add:  Time::HoursMinutes(1, 0, None),
-        letters:      Some("D"),
-    }));
-
-    test!(example_2: "Rule	Greece	1976	only	-	Oct	10	2:00s	0	-" => Line::Rule(Rule {
-        name:         "Greece",
-        from_year:    Year::Number(1976),
-        to_year:      None,
-        month:        Month(local::Month::October),
-        day:          Day::Ordinal(10),
-        time_of_day:  Time::HoursMinutes(2, 0, Some('s')),
-        time_to_add:  Time::Hours(0),
-        letters:      None,
-    }));
-
-    test!(rule_3: "Rule	EU	1977	1980	-	Apr	Sun>=1	 1:00u	1:00	S" => Line::Rule(Rule {
-        name: "EU",
-        from_year: Year::Number(1977),
-        to_year: Some(Year::Number(1980)),
-        month: Month(local::Month::April),
-        day: Day::LastOnOrAfter(Weekday(local::Weekday::Sunday), 1),
-        time_of_day: Time::HoursMinutes(1, 0, Some('u')),
-        time_to_add: Time::HoursMinutes(1, 0, None),
-        letters:     Some("S"),
-    }));
-
-    test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Line::Zone(Zone {
-        name: "Australia/Adelaide",
-        info: ZoneInfo {
-            gmt_offset:  Time::HoursMinutes(9, 30, None),
-            rules_save:  RulesSave::Rules("Aus"),
-            format:      "AC%sT",
-            time:        Some(ZoneTime::UntilTime(Year::Number(1971), Month(local::Month::October), Day::Ordinal(31), Time::HoursMinutesSeconds(2, 0, 0, None))),
-        },
-    }));
-
-    test!(continuation: "                          9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Line::Continuation(ZoneInfo {
-        gmt_offset:  Time::HoursMinutes(9, 30, None),
-        rules_save:  RulesSave::Rules("Aus"),
-        format:      "AC%sT",
-        time:        Some(ZoneTime::UntilTime(Year::Number(1971), Month(local::Month::October), Day::Ordinal(31), Time::HoursMinutesSeconds(2, 0, 0, None))),
-    }));
-
-    test!(link: "Link  Europe/Istanbul  Asia/Istanbul" => Line::Link(Link {
-        existing:  "Europe/Istanbul",
-        new:       "Asia/Istanbul",
-    }));
-
-    test!(continuatio2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Line::Continuation(ZoneInfo {
-        gmt_offset:  Time::HoursMinutes(1, 00, None),
-        rules_save:  RulesSave::Rules("C-Eur"),
-        format:      "CE%sT",
-        time:        Some(ZoneTime::UntilDay(Year::Number(1943), Month(local::Month::October), Day::Ordinal(25))),
-    }));
-
-    test!(zone_hyphen: "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919" => Line::Zone(Zone {
-        name: "Asia/Ust-Nera",
-        info: ZoneInfo {
-            gmt_offset:  Time::HoursMinutesSeconds(9, 32, 54, None),
-            rules_save:  RulesSave::Neither,
-            format:      "LMT",
-            time:        Some(ZoneTime::UntilYear(Year::Number(1919))),
-        },
-    }));
-
-    /// "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919 Dec 15"
-
-    #[test]
-    fn month() {
-        assert_eq!(Month::from_str("Aug"), Ok(Month(local::Month::August)));
-        assert_eq!(Month::from_str("December"), Ok(Month(local::Month::December)));
-    }
+#[macro_use] extern crate lazy_static;
 
-    #[test]
-    fn golb() {
-        assert!(Line::from_str("GOLB").is_err());
-    }
-}
+mod line;
+pub use line::*;
diff --git a/src/line.rs b/src/line.rs
new file mode 100644
index 0000000..dac8aaa
--- /dev/null
+++ b/src/line.rs
@@ -0,0 +1,654 @@
+use std::ascii::AsciiExt;
+use std::str::FromStr;
+
+use datetime::local;
+
+use regex::{Regex, Captures};
+
+
+/// A set of regexes to test against.
+///
+/// All of these regexes use the `(?x)` flag, which means they support
+/// comments and whitespace directly in the regex string!
+lazy_static! {
+
+    /// Format of a Rule line: one capturing group per field.
+    static ref RULE_LINE: Regex = Regex::new(r##"(?x) ^
+        Rule \s+
+        ( ?P<name>    \S+)  \s+
+        ( ?P<from>    \S+)  \s+
+        ( ?P<to>      \S+)  \s+
+        ( ?P<type>    \S+)  \s+
+        ( ?P<in>      \S+)  \s+
+        ( ?P<on>      \S+)  \s+
+        ( ?P<at>      \S+)  \s+
+        ( ?P<save>    \S+)  \s+
+        ( ?P<letters> \S+)
+    "##).unwrap();
+
+    /// Format of a Day specification in a Rule.
+    static ref DAY_FIELD: Regex = Regex::new(r##"(?x) ^
+        ( ?P<weekday> \w+ )
+        ( ?P<sign>    [<>] = )
+        ( ?P<day>     \d+ )
+    $ "##).unwrap();
+
+    /// Format of an hour and a minute.
+    static ref HM_FIELD: Regex = Regex::new(r##"(?x) ^
+        ( ?P<hour> -? \d{1,2} ) : ( ?P<minute> \d{2} )
+        ( ?P<flag> [wsugz] )?
+    $ "##).unwrap();
+
+    /// Format of an hour, a minute, and a second.
+    static ref HMS_FIELD: Regex = Regex::new(r##"(?x) ^
+        ( ?P<hour> -? \d{1,2} ) : ( ?P<minute> \d{2} ) : ( ?P<second> \d{2} )
+        ( ?P<flag> [wsugz] )?
+    $ "##).unwrap();
+
+    /// Format of a Zone line, with one capturing group per field.
+    static ref ZONE_LINE: Regex = Regex::new(r##"(?x) ^
+        Zone \s+
+        ( ?P<name> [ A-Z a-z 0-9 / _ + - ]+ )  \s+
+        ( ?P<gmtoff>     \S+ )  \s+
+        ( ?P<rulessave>  \S+ )  \s+
+        ( ?P<format>     \S+ )  \s*
+        ( ?P<year>       \S+ )? \s*
+        ( ?P<month>      \S+ )? \s*
+        ( ?P<day>        \S+ )? \s*
+        ( ?P<time>       \S+ )?
+    "##).unwrap();
+
+    /// Format of a Continuation Zone line, which is the same as the opening
+    /// Zone line except the first two fields are replaced by whitespace.
+    static ref CONTINUATION_LINE: Regex = Regex::new(r##"(?x) ^
+        \s+
+        ( ?P<gmtoff>     \S+ )  \s+
+        ( ?P<rulessave>  \S+ )  \s+
+        ( ?P<format>     \S+ )  \s*
+        ( ?P<year>       \S+ )? \s*
+        ( ?P<month>      \S+ )? \s*
+        ( ?P<day>        \S+ )? \s*
+        ( ?P<time>       \S+ )?
+    "##).unwrap();
+
+    /// Format of a Link line, with one capturing group per field.
+    static ref LINK_LINE: Regex = Regex::new(r##"(?x) ^
+        Link  \s+
+        ( ?P<target>  \S+ )  \s+
+        ( ?P<name>    \S+ )
+    "##).unwrap();
+}
+
+
+/// A **rule** definition line.
+///
+/// According to the `zic` man page, a rule line has the form:
+///
+/// A rule line has the form:
+///
+/// ```text
+///         Rule  NAME  FROM  TO    TYPE  IN   ON       AT    SAVE  LETTER/S
+///    For example:
+///         Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D
+/// ```
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Rule<'line> {
+
+    /// The name of the set of rules that this rule is part of.
+    pub name: &'line str,
+
+    /// The first year in which the rule applies.
+    pub from_year: Year,
+
+    /// The final year, or `None` if's 'only'.
+    pub to_year: Option<Year>,
+
+    /// The month in which the rule takes effect.
+    pub month: Month,
+
+    /// The day on which the rule takes effect.
+    pub day: Day,
+
+    /// The time of day at which the rule takes effect.
+    pub time_of_day: Time,
+
+    /// The amount of time to be added when the rule is in effect.
+    pub time_to_add: Time,
+
+    /// The variable part of time zone abbreviations to be used when this rule
+    /// is in effect, if any.
+    pub letters: Option<&'line str>,
+}
+
+impl<'line> Rule<'line> {
+
+    /// Attempts to parse the given string into a value of this type.
+    fn from_str(input: &str) -> Result<Rule, Error> {
+        if let Some(caps) = RULE_LINE.captures(input) {
+            let name         = caps.name("name").unwrap();
+            let from_year    = try!(caps.name("from").unwrap().parse());
+            let to_year      = match caps.name("to").unwrap() {
+                "only"  => None,
+                to      => Some(try!(to.parse())),
+            };
+
+            // According to the spec, the only value inside the 'type' column
+            // should be "-", so throw an error if it isn't.
+            let t = caps.name("type").unwrap();
+            if t != "-" && t != "\u{2010}"  {
+                return Err(Error::Fail);
+            }
+
+            let month         = try!(caps.name("in").unwrap().parse());
+            let day           = try!(caps.name("on").unwrap().parse());
+            let time_of_day   = try!(caps.name("at").unwrap().parse());
+            let time_to_add   = try!(caps.name("save").unwrap().parse());
+            let letters       = match caps.name("letters").unwrap() {
+                "-"  => None,
+                l    => Some(l),
+            };
+
+            Ok(Rule {
+                name: name,
+                from_year:    from_year,
+                to_year:      to_year,
+                month:        month,
+                day:          day,
+                time_of_day:  time_of_day,
+                time_to_add:  time_to_add,
+                letters:      letters,
+            })
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// A **year** definition field.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Year {
+
+    /// The minimum year possible: `min` or `minimum` in a file.
+    Minimum,
+
+    /// The maximum year possible: `max` or `maximum` in a file.
+    Maximum,
+
+    /// A specific year number.
+    Number(i32),
+}
+
+impl FromStr for Year {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Year, Self::Err> {
+        if input == "min" || input == "minimum" {
+            Ok(Year::Minimum)
+        }
+        else if input == "max" || input == "maximum" {
+            Ok(Year::Maximum)
+        }
+        else if input.chars().all(|c| c.is_digit(10)) {
+            Ok(Year::Number(input.parse().unwrap()))
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// A **month** field, which is actually just a wrapper around
+/// `datetime::local::Month`.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Month(local::Month);
+
+impl FromStr for Month {
+    type Err = Error;
+
+    /// Attempts to parse the given string into a value of this type.
+    fn from_str(input: &str) -> Result<Month, Self::Err> {
+        Ok(match &*input.to_ascii_lowercase() {
+            "jan" | "january"    => Month(local::Month::January),
+            "feb" | "february"   => Month(local::Month::February),
+            "mar" | "march"      => Month(local::Month::March),
+            "apr" | "april"      => Month(local::Month::April),
+            "may"                => Month(local::Month::May),
+            "jun" | "june"       => Month(local::Month::June),
+            "jul" | "july"       => Month(local::Month::July),
+            "aug" | "august"     => Month(local::Month::August),
+            "sep" | "september"  => Month(local::Month::September),
+            "oct" | "october"    => Month(local::Month::October),
+            "nov" | "november"   => Month(local::Month::November),
+            "dec" | "december"   => Month(local::Month::December),
+                  _              => return Err(Error::Fail),
+        })
+    }
+}
+
+
+/// A **weekday** field, which is actually just a wrapper around
+/// `datetime::local::Weekday`.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Weekday(local::Weekday);
+
+impl FromStr for Weekday {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Weekday, Self::Err> {
+
+        Ok(match &*input.to_ascii_lowercase() {
+            "mon" | "monday"     => Weekday(local::Weekday::Monday),
+            "tue" | "tuesday"    => Weekday(local::Weekday::Tuesday),
+            "wed" | "wednesday"  => Weekday(local::Weekday::Wednesday),
+            "thu" | "thursday"   => Weekday(local::Weekday::Thursday),
+            "fri" | "friday"     => Weekday(local::Weekday::Friday),
+            "sat" | "saturday"   => Weekday(local::Weekday::Saturday),
+            "sun" | "sunday"     => Weekday(local::Weekday::Sunday),
+                  _              => return Err(Error::Fail),
+        })
+    }
+}
+
+
+/// A **day** definition field.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Day {
+
+    /// A specific day of the month.
+    Ordinal(i32),
+
+    /// The last day of the month with a specific weekday.
+    Last(Weekday),
+
+    /// The last day **before** a point with a specific weekday.
+    LastOnOrBefore(Weekday, i32),
+
+    /// The last day **after** a point with a specific weekday.
+    LastOnOrAfter(Weekday, i32)
+}
+
+impl FromStr for Day {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Day, Self::Err> {
+        if input.chars().all(|c| c.is_digit(10)) {
+            Ok(Day::Ordinal(input.parse().unwrap()))
+        }
+        else if input.starts_with("last") {
+            let weekday = try!(input[4..].parse());
+            Ok(Day::Last(weekday))
+        }
+        else if let Some(caps) = DAY_FIELD.captures(input) {
+            let weekday = caps.name("weekday").unwrap().parse().unwrap();
+            let day     = caps.name("day").unwrap().parse().unwrap();
+
+            match caps.name("sign").unwrap() {
+                "<=" => Ok(Day::LastOnOrBefore(weekday, day)),
+                ">=" => Ok(Day::LastOnOrAfter(weekday, day)),
+                 _   => unreachable!("The regex only matches one of those two"),
+            }
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// A **time** definition field.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Time {
+
+    /// A number of hours.
+    Hours(i32),
+
+    /// A number of hours and minutes.
+    HoursMinutes(i32, i32, Option<char>),
+
+    /// A number of hours, minutes, and seconds.
+    HoursMinutesSeconds(i32, i32, i32, Option<char>),
+
+    /// Zero, or midnight at the start of the day.
+    Zero,
+}
+
+impl FromStr for Time {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Time, Self::Err> {
+
+        if input == "-" {
+            Ok(Time::Zero)
+        }
+        else if input.chars().all(|c| c == '-' || c.is_digit(10)) {
+            Ok(Time::Hours(input.parse().unwrap()))
+        }
+        else if let Some(caps) = HM_FIELD.captures(input) {
+            let hour   = caps.name("hour").unwrap().parse().unwrap();
+            let minute = caps.name("minute").unwrap().parse().unwrap();
+            let flag   = caps.name("flag").map(|f| f.chars().next().unwrap());
+            Ok(Time::HoursMinutes(hour, minute, flag))
+        }
+        else if let Some(caps) = HMS_FIELD.captures(input) {
+            let hour   = caps.name("hour").unwrap().parse().unwrap();
+            let minute = caps.name("minute").unwrap().parse().unwrap();
+            let second = caps.name("second").unwrap().parse().unwrap();
+            let flag   = caps.name("flag").map(|f| f.chars().next().unwrap());
+            Ok(Time::HoursMinutesSeconds(hour, minute, second, flag))
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// A **zone** definition line.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Zone<'line> {
+
+    /// The name of the time zone.
+    pub name: &'line str,
+
+    /// All the other fields of info.
+    pub info: ZoneInfo<'line>,
+}
+
+/// The information contained in both zone lines and zone continuation lines.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct ZoneInfo<'line> {
+
+    /// The amount of time to be added to Universal Time, to get standard time
+    /// in this zone.
+    pub gmt_offset: Time,
+
+    /// The name of all the rules that should apply in the time zone, or the
+    /// amount of time to add.
+    pub rules_save: RulesSave<'line>,
+
+    /// The format for time zone abbreviations, with `%s` as the string marker.
+    pub format: &'line str,
+
+    /// The time at which the rules change for this location, or `None` if these rules
+    pub time: Option<ZoneTime>,
+}
+
+impl<'line> Zone<'line> {
+    fn from_str(input: &str) -> Result<Zone, Error> {
+        if let Some(caps) = ZONE_LINE.captures(input) {
+            let name = caps.name("name").unwrap();
+            let info = try!(ZoneInfo::from_captures(caps));
+
+            Ok(Zone {
+                name: name,
+                info: info,
+            })
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+impl<'line> ZoneInfo<'line> {
+    fn from_captures(caps: Captures<'line>) -> Result<ZoneInfo<'line>, Error> {
+        let gmt_offset    = try!(caps.name("gmtoff").unwrap().parse());
+        let rules_save    = try!(RulesSave::from_str(caps.name("rulessave").unwrap()));
+        let format        = caps.name("format").unwrap();
+
+        let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
+            (Some(y), Some(m), Some(d), Some(t)) => Some(ZoneTime::UntilTime  (try!(y.parse()), try!(m.parse()), try!(d.parse()), try!(t.parse()))),
+            (Some(y), Some(m), Some(d), _      ) => Some(ZoneTime::UntilDay   (try!(y.parse()), try!(m.parse()), try!(d.parse()))),
+            (Some(y), Some(m), _      , _      ) => Some(ZoneTime::UntilMonth (try!(y.parse()), try!(m.parse()))),
+            (Some(y), _      , _      , _      ) => Some(ZoneTime::UntilYear  (try!(y.parse()))),
+            (None   , None   , None   , None   ) => None,
+            _                                    => return Err(Error::Fail),
+        };
+
+        Ok(ZoneInfo {
+            gmt_offset:  gmt_offset,
+            rules_save:  rules_save,
+            format:      format,
+            time:        time,
+        })
+    }
+}
+
+
+/// A specific type for a certain Zone column.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum RulesSave<'line> {
+
+    /// The name of the **rules** to apply.
+    Rules(&'line str),
+
+    /// The amount of **save** time to add.
+    Save(Time),
+
+    /// Neither of these were specified.
+    Neither,
+}
+
+impl<'line> RulesSave<'line> {
+    fn from_str(input: &str) -> Result<RulesSave, Error> {
+        if input == "-" {
+            Ok(RulesSave::Neither)
+        }
+        else if input.chars().all(|c| c == '-' || c == '_' || c.is_alphabetic()) {
+            Ok(RulesSave::Rules(input))
+        }
+        else if HM_FIELD.is_match(input) {
+            let time = try!(input.parse());
+            Ok(RulesSave::Save(time))
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// The time at which the rules change for a location, with varying degrees of precision.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum ZoneTime {
+
+    /// The earliest point in a particular **year**.
+    UntilYear(Year),
+
+    /// The earliest point in a particular **month**.
+    UntilMonth(Year, Month),
+
+    /// The earliest point in a particular **day**.
+    UntilDay(Year, Month, Day),
+
+    /// The earliest point in a particular hour, minute, or second, or one of
+    /// those small time units, anyway.
+    UntilTime(Year, Month, Day, Time),
+}
+
+
+/// A **link** definition line.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Link<'line> {
+
+    /// The target time zone, which should appear as the name in a zone definition.
+    existing: &'line str,
+
+    /// Another name that the target can be called.
+    new: &'line str,
+}
+
+impl<'line> Link<'line> {
+    fn from_str(input: &str) -> Result<Link, Error> {
+        if let Some(caps) = LINK_LINE.captures(input) {
+            let target  = caps.name("target").unwrap();
+            let name    = caps.name("name").unwrap();
+            Ok(Link { existing: target, new: name })
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// An error that can occur during parsing.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Error {
+
+    /// TODO: more error types
+    Fail
+}
+
+/// A type of valid line that has been parsed.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Line<'line> {
+
+    /// This line is empty.
+    Space,
+
+    /// This line contains a **zone** definition.
+    Zone(Zone<'line>),
+
+    /// This line contains a **continuation** of a zone definition.
+    Continuation(ZoneInfo<'line>),
+
+    /// This line contains a **rule** definition.
+    Rule(Rule<'line>),
+
+    /// This line contains a **link** definition.
+    Link(Link<'line>),
+}
+
+impl<'line> Line<'line> {
+
+    /// Attempts to parse the given string into a value of this type.
+    pub fn from_str(input: &str) -> Result<Line, Error> {
+        if input.is_empty() || input.chars().all(char::is_whitespace) {
+            Ok(Line::Space)
+        }
+        else if let Ok(zone) = Zone::from_str(input) {
+            Ok(Line::Zone(zone))
+        }
+        else if let Some(caps) = CONTINUATION_LINE.captures(input) {
+            Ok(Line::Continuation(try!(ZoneInfo::from_captures(caps))))
+        }
+        else if let Ok(rule) = Rule::from_str(input) {
+            Ok(Line::Rule(rule))
+        }
+        else if let Ok(link) = Link::from_str(input) {
+            Ok(Line::Link(link))
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+#[cfg(test)]
+mod test {
+    use std::str::FromStr;
+
+    use super::*;
+    use datetime::local;
+
+    macro_rules! test {
+        ($name:ident: $input:expr => $result:expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!(Line::from_str($input), Ok($result));
+            }
+        };
+    }
+
+    test!(empty:    ""           => Line::Space);
+
+    test!(example: "Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D" => Line::Rule(Rule {
+        name:         "US",
+        from_year:    Year::Number(1967),
+        to_year:      Some(Year::Number(1973)),
+        month:        Month(local::Month::April),
+        day:          Day::Last(Weekday(local::Weekday::Sunday)),
+        time_of_day:  Time::HoursMinutes(2, 0, None),
+        time_to_add:  Time::HoursMinutes(1, 0, None),
+        letters:      Some("D"),
+    }));
+
+    test!(example_2: "Rule	Greece	1976	only	-	Oct	10	2:00s	0	-" => Line::Rule(Rule {
+        name:         "Greece",
+        from_year:    Year::Number(1976),
+        to_year:      None,
+        month:        Month(local::Month::October),
+        day:          Day::Ordinal(10),
+        time_of_day:  Time::HoursMinutes(2, 0, Some('s')),
+        time_to_add:  Time::Hours(0),
+        letters:      None,
+    }));
+
+    test!(rule_3: "Rule	EU	1977	1980	-	Apr	Sun>=1	 1:00u	1:00	S" => Line::Rule(Rule {
+        name: "EU",
+        from_year: Year::Number(1977),
+        to_year: Some(Year::Number(1980)),
+        month: Month(local::Month::April),
+        day: Day::LastOnOrAfter(Weekday(local::Weekday::Sunday), 1),
+        time_of_day: Time::HoursMinutes(1, 0, Some('u')),
+        time_to_add: Time::HoursMinutes(1, 0, None),
+        letters:     Some("S"),
+    }));
+
+    test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Line::Zone(Zone {
+        name: "Australia/Adelaide",
+        info: ZoneInfo {
+            gmt_offset:  Time::HoursMinutes(9, 30, None),
+            rules_save:  RulesSave::Rules("Aus"),
+            format:      "AC%sT",
+            time:        Some(ZoneTime::UntilTime(Year::Number(1971), Month(local::Month::October), Day::Ordinal(31), Time::HoursMinutesSeconds(2, 0, 0, None))),
+        },
+    }));
+
+    test!(continuation: "                          9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Line::Continuation(ZoneInfo {
+        gmt_offset:  Time::HoursMinutes(9, 30, None),
+        rules_save:  RulesSave::Rules("Aus"),
+        format:      "AC%sT",
+        time:        Some(ZoneTime::UntilTime(Year::Number(1971), Month(local::Month::October), Day::Ordinal(31), Time::HoursMinutesSeconds(2, 0, 0, None))),
+    }));
+
+    test!(link: "Link  Europe/Istanbul  Asia/Istanbul" => Line::Link(Link {
+        existing:  "Europe/Istanbul",
+        new:       "Asia/Istanbul",
+    }));
+
+    test!(continuatio2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Line::Continuation(ZoneInfo {
+        gmt_offset:  Time::HoursMinutes(1, 00, None),
+        rules_save:  RulesSave::Rules("C-Eur"),
+        format:      "CE%sT",
+        time:        Some(ZoneTime::UntilDay(Year::Number(1943), Month(local::Month::October), Day::Ordinal(25))),
+    }));
+
+    test!(zone_hyphen: "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919" => Line::Zone(Zone {
+        name: "Asia/Ust-Nera",
+        info: ZoneInfo {
+            gmt_offset:  Time::HoursMinutesSeconds(9, 32, 54, None),
+            rules_save:  RulesSave::Neither,
+            format:      "LMT",
+            time:        Some(ZoneTime::UntilYear(Year::Number(1919))),
+        },
+    }));
+
+    /// "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919 Dec 15"
+
+    #[test]
+    fn month() {
+        assert_eq!(Month::from_str("Aug"), Ok(Month(local::Month::August)));
+        assert_eq!(Month::from_str("December"), Ok(Month(local::Month::December)));
+    }
+
+    #[test]
+    fn golb() {
+        assert!(Line::from_str("GOLB").is_err());
+    }
+}

From c6f60a3f6ded346af93bec431d3aba7c4b44e68c Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sun, 27 Sep 2015 19:20:07 +0100
Subject: [PATCH 006/113] Line module docs, tests, and reorganisation

---
 src/line.rs | 711 +++++++++++++++++++++++++++++++---------------------
 1 file changed, 420 insertions(+), 291 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index dac8aaa..f36c55a 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -26,25 +26,27 @@ lazy_static! {
         ( ?P<letters> \S+)
     "##).unwrap();
 
-    /// Format of a Day specification in a Rule.
+    /// Format of a day specification.
     static ref DAY_FIELD: Regex = Regex::new(r##"(?x) ^
         ( ?P<weekday> \w+ )
         ( ?P<sign>    [<>] = )
         ( ?P<day>     \d+ )
     $ "##).unwrap();
 
-    /// Format of an hour and a minute.
+    /// Format of an hour and a minute specification.
     static ref HM_FIELD: Regex = Regex::new(r##"(?x) ^
         ( ?P<hour> -? \d{1,2} ) : ( ?P<minute> \d{2} )
         ( ?P<flag> [wsugz] )?
     $ "##).unwrap();
 
-    /// Format of an hour, a minute, and a second.
+    /// Format of an hour, a minute, and a second specification.
     static ref HMS_FIELD: Regex = Regex::new(r##"(?x) ^
         ( ?P<hour> -? \d{1,2} ) : ( ?P<minute> \d{2} ) : ( ?P<second> \d{2} )
         ( ?P<flag> [wsugz] )?
     $ "##).unwrap();
 
+    // ^ those two could be done with the same regex, but... they aren't.
+
     /// Format of a Zone line, with one capturing group per field.
     static ref ZONE_LINE: Regex = Regex::new(r##"(?x) ^
         Zone \s+
@@ -82,15 +84,16 @@ lazy_static! {
 
 /// A **rule** definition line.
 ///
-/// According to the `zic` man page, a rule line has the form:
-///
-/// A rule line has the form:
+/// According to the `zic(8)` man page, a rule line has this form, along with
+/// an example:
 ///
 /// ```text
-///         Rule  NAME  FROM  TO    TYPE  IN   ON       AT    SAVE  LETTER/S
-///    For example:
-///         Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D
+///     Rule  NAME  FROM  TO    TYPE  IN   ON       AT    SAVE  LETTER/S
+///     Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D
 /// ```
+///
+/// Apart from the opening `Rule` to specify which kind of line this is, and
+/// the `type` column, every column in the line has a field in this struct.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub struct Rule<'line> {
 
@@ -98,22 +101,22 @@ pub struct Rule<'line> {
     pub name: &'line str,
 
     /// The first year in which the rule applies.
-    pub from_year: Year,
+    pub from_year: YearSpec,
 
     /// The final year, or `None` if's 'only'.
-    pub to_year: Option<Year>,
+    pub to_year: Option<YearSpec>,
 
     /// The month in which the rule takes effect.
-    pub month: Month,
+    pub month: MonthSpec,
 
     /// The day on which the rule takes effect.
-    pub day: Day,
+    pub day: DaySpec,
 
     /// The time of day at which the rule takes effect.
-    pub time_of_day: Time,
+    pub time_of_day: TimeSpec,
 
     /// The amount of time to be added when the rule is in effect.
-    pub time_to_add: Time,
+    pub time_to_add: TimeSpec,
 
     /// The variable part of time zone abbreviations to be used when this rule
     /// is in effect, if any.
@@ -127,13 +130,18 @@ impl<'line> Rule<'line> {
         if let Some(caps) = RULE_LINE.captures(input) {
             let name         = caps.name("name").unwrap();
             let from_year    = try!(caps.name("from").unwrap().parse());
+
+            // The end year can be 'only' to indicate that this rule only
+            // takes place on that year.
             let to_year      = match caps.name("to").unwrap() {
                 "only"  => None,
                 to      => Some(try!(to.parse())),
             };
 
             // According to the spec, the only value inside the 'type' column
-            // should be "-", so throw an error if it isn't.
+            // should be "-", so throw an error if it isn't. (It only exists
+            // for compatibility with old versions that used to contain year
+            // types.) Sometimes "‐", a Unicode hyphen, is used as well.
             let t = caps.name("type").unwrap();
             if t != "-" && t != "\u{2010}"  {
                 return Err(Error::Fail);
@@ -149,7 +157,7 @@ impl<'line> Rule<'line> {
             };
 
             Ok(Rule {
-                name: name,
+                name:         name,
                 from_year:    from_year,
                 to_year:      to_year,
                 month:        month,
@@ -165,188 +173,25 @@ impl<'line> Rule<'line> {
     }
 }
 
-
-/// A **year** definition field.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum Year {
-
-    /// The minimum year possible: `min` or `minimum` in a file.
-    Minimum,
-
-    /// The maximum year possible: `max` or `maximum` in a file.
-    Maximum,
-
-    /// A specific year number.
-    Number(i32),
-}
-
-impl FromStr for Year {
-    type Err = Error;
-
-    fn from_str(input: &str) -> Result<Year, Self::Err> {
-        if input == "min" || input == "minimum" {
-            Ok(Year::Minimum)
-        }
-        else if input == "max" || input == "maximum" {
-            Ok(Year::Maximum)
-        }
-        else if input.chars().all(|c| c.is_digit(10)) {
-            Ok(Year::Number(input.parse().unwrap()))
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-
-/// A **month** field, which is actually just a wrapper around
-/// `datetime::local::Month`.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct Month(local::Month);
-
-impl FromStr for Month {
-    type Err = Error;
-
-    /// Attempts to parse the given string into a value of this type.
-    fn from_str(input: &str) -> Result<Month, Self::Err> {
-        Ok(match &*input.to_ascii_lowercase() {
-            "jan" | "january"    => Month(local::Month::January),
-            "feb" | "february"   => Month(local::Month::February),
-            "mar" | "march"      => Month(local::Month::March),
-            "apr" | "april"      => Month(local::Month::April),
-            "may"                => Month(local::Month::May),
-            "jun" | "june"       => Month(local::Month::June),
-            "jul" | "july"       => Month(local::Month::July),
-            "aug" | "august"     => Month(local::Month::August),
-            "sep" | "september"  => Month(local::Month::September),
-            "oct" | "october"    => Month(local::Month::October),
-            "nov" | "november"   => Month(local::Month::November),
-            "dec" | "december"   => Month(local::Month::December),
-                  _              => return Err(Error::Fail),
-        })
-    }
-}
-
-
-/// A **weekday** field, which is actually just a wrapper around
-/// `datetime::local::Weekday`.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub struct Weekday(local::Weekday);
-
-impl FromStr for Weekday {
-    type Err = Error;
-
-    fn from_str(input: &str) -> Result<Weekday, Self::Err> {
-
-        Ok(match &*input.to_ascii_lowercase() {
-            "mon" | "monday"     => Weekday(local::Weekday::Monday),
-            "tue" | "tuesday"    => Weekday(local::Weekday::Tuesday),
-            "wed" | "wednesday"  => Weekday(local::Weekday::Wednesday),
-            "thu" | "thursday"   => Weekday(local::Weekday::Thursday),
-            "fri" | "friday"     => Weekday(local::Weekday::Friday),
-            "sat" | "saturday"   => Weekday(local::Weekday::Saturday),
-            "sun" | "sunday"     => Weekday(local::Weekday::Sunday),
-                  _              => return Err(Error::Fail),
-        })
-    }
-}
-
-
-/// A **day** definition field.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum Day {
-
-    /// A specific day of the month.
-    Ordinal(i32),
-
-    /// The last day of the month with a specific weekday.
-    Last(Weekday),
-
-    /// The last day **before** a point with a specific weekday.
-    LastOnOrBefore(Weekday, i32),
-
-    /// The last day **after** a point with a specific weekday.
-    LastOnOrAfter(Weekday, i32)
-}
-
-impl FromStr for Day {
-    type Err = Error;
-
-    fn from_str(input: &str) -> Result<Day, Self::Err> {
-        if input.chars().all(|c| c.is_digit(10)) {
-            Ok(Day::Ordinal(input.parse().unwrap()))
-        }
-        else if input.starts_with("last") {
-            let weekday = try!(input[4..].parse());
-            Ok(Day::Last(weekday))
-        }
-        else if let Some(caps) = DAY_FIELD.captures(input) {
-            let weekday = caps.name("weekday").unwrap().parse().unwrap();
-            let day     = caps.name("day").unwrap().parse().unwrap();
-
-            match caps.name("sign").unwrap() {
-                "<=" => Ok(Day::LastOnOrBefore(weekday, day)),
-                ">=" => Ok(Day::LastOnOrAfter(weekday, day)),
-                 _   => unreachable!("The regex only matches one of those two"),
-            }
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-
-/// A **time** definition field.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum Time {
-
-    /// A number of hours.
-    Hours(i32),
-
-    /// A number of hours and minutes.
-    HoursMinutes(i32, i32, Option<char>),
-
-    /// A number of hours, minutes, and seconds.
-    HoursMinutesSeconds(i32, i32, i32, Option<char>),
-
-    /// Zero, or midnight at the start of the day.
-    Zero,
-}
-
-impl FromStr for Time {
-    type Err = Error;
-
-    fn from_str(input: &str) -> Result<Time, Self::Err> {
-
-        if input == "-" {
-            Ok(Time::Zero)
-        }
-        else if input.chars().all(|c| c == '-' || c.is_digit(10)) {
-            Ok(Time::Hours(input.parse().unwrap()))
-        }
-        else if let Some(caps) = HM_FIELD.captures(input) {
-            let hour   = caps.name("hour").unwrap().parse().unwrap();
-            let minute = caps.name("minute").unwrap().parse().unwrap();
-            let flag   = caps.name("flag").map(|f| f.chars().next().unwrap());
-            Ok(Time::HoursMinutes(hour, minute, flag))
-        }
-        else if let Some(caps) = HMS_FIELD.captures(input) {
-            let hour   = caps.name("hour").unwrap().parse().unwrap();
-            let minute = caps.name("minute").unwrap().parse().unwrap();
-            let second = caps.name("second").unwrap().parse().unwrap();
-            let flag   = caps.name("flag").map(|f| f.chars().next().unwrap());
-            Ok(Time::HoursMinutesSeconds(hour, minute, second, flag))
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
-
 /// A **zone** definition line.
+///
+/// According to the `zic(8)` man page, a zone line has this form, along with
+/// an example:
+///
+/// ```text
+///     Zone  NAME                GMTOFF  RULES/SAVE  FORMAT  [UNTILYEAR [MONTH [DAY [TIME]]]]
+///     Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971       Oct    31   2:00
+/// ```
+///
+/// The opening `Zone` identifier is ignored, and the last four columns are
+/// all optional, with their variants consolidated into a `ZoneTime`.
+///
+/// The `Rules/Save` column, if it contains a value, *either* contains the
+/// name of the rules to use for this zone, *or* contains a one-off period of
+/// time to save.
+///
+/// A continuation rule line contains all the same fields apart from the
+/// `Name` column and the opening `Zone` identifier.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub struct Zone<'line> {
 
@@ -357,13 +202,13 @@ pub struct Zone<'line> {
     pub info: ZoneInfo<'line>,
 }
 
-/// The information contained in both zone lines and zone continuation lines.
+/// The information contained in both zone lines *and* zone continuation lines.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub struct ZoneInfo<'line> {
 
-    /// The amount of time to be added to Universal Time, to get standard time
+    /// The amount of time to be added to Universal TimeSpec, to get standard time
     /// in this zone.
-    pub gmt_offset: Time,
+    pub gmt_offset: TimeSpec,
 
     /// The name of all the rules that should apply in the time zone, or the
     /// amount of time to add.
@@ -399,13 +244,16 @@ impl<'line> ZoneInfo<'line> {
         let rules_save    = try!(RulesSave::from_str(caps.name("rulessave").unwrap()));
         let format        = caps.name("format").unwrap();
 
+        // The year, month, day, and time fields are all optional, meaning
+        // that it should be impossible to, say, have a defined month but not
+        // a defined year.
         let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
             (Some(y), Some(m), Some(d), Some(t)) => Some(ZoneTime::UntilTime  (try!(y.parse()), try!(m.parse()), try!(d.parse()), try!(t.parse()))),
             (Some(y), Some(m), Some(d), _      ) => Some(ZoneTime::UntilDay   (try!(y.parse()), try!(m.parse()), try!(d.parse()))),
             (Some(y), Some(m), _      , _      ) => Some(ZoneTime::UntilMonth (try!(y.parse()), try!(m.parse()))),
             (Some(y), _      , _      , _      ) => Some(ZoneTime::UntilYear  (try!(y.parse()))),
             (None   , None   , None   , None   ) => None,
-            _                                    => return Err(Error::Fail),
+            _                                    => unreachable!("Out-of-order capturing groups!"),
         };
 
         Ok(ZoneInfo {
@@ -426,7 +274,7 @@ pub enum RulesSave<'line> {
     Rules(&'line str),
 
     /// The amount of **save** time to add.
-    Save(Time),
+    Save(TimeSpec),
 
     /// Neither of these were specified.
     Neither,
@@ -456,17 +304,17 @@ impl<'line> RulesSave<'line> {
 pub enum ZoneTime {
 
     /// The earliest point in a particular **year**.
-    UntilYear(Year),
+    UntilYear(YearSpec),
 
     /// The earliest point in a particular **month**.
-    UntilMonth(Year, Month),
+    UntilMonth(YearSpec, MonthSpec),
 
     /// The earliest point in a particular **day**.
-    UntilDay(Year, Month, Day),
+    UntilDay(YearSpec, MonthSpec, DaySpec),
 
     /// The earliest point in a particular hour, minute, or second, or one of
     /// those small time units, anyway.
-    UntilTime(Year, Month, Day, Time),
+    UntilTime(YearSpec, MonthSpec, DaySpec, TimeSpec),
 }
 
 
@@ -475,10 +323,10 @@ pub enum ZoneTime {
 pub struct Link<'line> {
 
     /// The target time zone, which should appear as the name in a zone definition.
-    existing: &'line str,
+    pub existing: &'line str,
 
     /// Another name that the target can be called.
-    new: &'line str,
+    pub new: &'line str,
 }
 
 impl<'line> Link<'line> {
@@ -495,6 +343,280 @@ impl<'line> Link<'line> {
 }
 
 
+/// A **year** definition field.
+///
+/// A year has one of the following representations in a file:
+///
+/// - `min` or `minimum`, the minimum year possible, for when a rule needs to
+///   apply up until the first rule with a specific year;
+/// - `max` or `maximum`, the maximum year possible, for when a rule needs to
+///   apply after the last rule with a specific year;
+/// - a year number, referring to a specific year.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum YearSpec {
+
+    /// The minimum year possible: `min` or `minimum`.
+    Minimum,
+
+    /// The maximum year possible: `max` or `maximum`.
+    Maximum,
+
+    /// A specific year number.
+    Number(i32),
+}
+
+impl FromStr for YearSpec {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<YearSpec, Self::Err> {
+        if input == "min" || input == "minimum" {
+            Ok(YearSpec::Minimum)
+        }
+        else if input == "max" || input == "maximum" {
+            Ok(YearSpec::Maximum)
+        }
+        else if input.chars().all(|c| c.is_digit(10)) {
+            Ok(YearSpec::Number(input.parse().unwrap()))
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
+/// A **month** field, which is actually just a wrapper around
+/// `datetime::local::Month`.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct MonthSpec(local::Month);
+
+impl FromStr for MonthSpec {
+    type Err = Error;
+
+    /// Attempts to parse the given string into a value of this type.
+    fn from_str(input: &str) -> Result<MonthSpec, Self::Err> {
+        Ok(match &*input.to_ascii_lowercase() {
+            "jan" | "january"    => MonthSpec(local::Month::January),
+            "feb" | "february"   => MonthSpec(local::Month::February),
+            "mar" | "march"      => MonthSpec(local::Month::March),
+            "apr" | "april"      => MonthSpec(local::Month::April),
+            "may"                => MonthSpec(local::Month::May),
+            "jun" | "june"       => MonthSpec(local::Month::June),
+            "jul" | "july"       => MonthSpec(local::Month::July),
+            "aug" | "august"     => MonthSpec(local::Month::August),
+            "sep" | "september"  => MonthSpec(local::Month::September),
+            "oct" | "october"    => MonthSpec(local::Month::October),
+            "nov" | "november"   => MonthSpec(local::Month::November),
+            "dec" | "december"   => MonthSpec(local::Month::December),
+                  _              => return Err(Error::Fail),
+        })
+    }
+}
+
+
+/// A **weekday** field, which is actually just a wrapper around
+/// `datetime::local::Weekday`.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct WeekdaySpec(local::Weekday);
+
+impl FromStr for WeekdaySpec {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<WeekdaySpec, Self::Err> {
+
+        Ok(match &*input.to_ascii_lowercase() {
+            "mon" | "monday"     => WeekdaySpec(local::Weekday::Monday),
+            "tue" | "tuesday"    => WeekdaySpec(local::Weekday::Tuesday),
+            "wed" | "wednesday"  => WeekdaySpec(local::Weekday::Wednesday),
+            "thu" | "thursday"   => WeekdaySpec(local::Weekday::Thursday),
+            "fri" | "friday"     => WeekdaySpec(local::Weekday::Friday),
+            "sat" | "saturday"   => WeekdaySpec(local::Weekday::Saturday),
+            "sun" | "sunday"     => WeekdaySpec(local::Weekday::Sunday),
+                  _              => return Err(Error::Fail),
+        })
+    }
+}
+
+
+/// A **day** definition field.
+///
+/// This can be given in either absolute terms (such as "the fifth day of the
+/// month"), or relative terms (such as "the last Sunday of the month", or
+/// "the last Friday before or including the 13th").
+///
+/// Note that in the last example, it's allowed for that particular Friday to
+/// *be* the 13th in question.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum DaySpec {
+
+    /// A specific day of the month, given by its number.
+    Ordinal(i32),
+
+    /// The last day of the month with a specific weekday.
+    Last(WeekdaySpec),
+
+    /// The **last** day with the given weekday **before** (or including) a
+    /// day with a specific number.
+    LastOnOrBefore(WeekdaySpec, i32),
+
+    /// The **first** day with the given weekday **after** (or including) a
+    /// day with a specific number.
+    FirstOnOrAfter(WeekdaySpec, i32)
+}
+
+impl FromStr for DaySpec {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<DaySpec, Self::Err> {
+
+        // Parse the field as a number if it vaguely resembles one.
+        if input.chars().all(|c| c.is_digit(10)) {
+            Ok(DaySpec::Ordinal(input.parse().unwrap()))
+        }
+
+        // Check if it stars with 'last', and trim off the first four bytes if
+        // it does. (Luckily, the file is ASCII.)
+        else if input.starts_with("last") {
+            let weekday = try!(input[4..].parse());
+            Ok(DaySpec::Last(weekday))
+        }
+
+        // Check if it's a relative expression with the regex.
+        else if let Some(caps) = DAY_FIELD.captures(input) {
+            let weekday = caps.name("weekday").unwrap().parse().unwrap();
+            let day     = caps.name("day").unwrap().parse().unwrap();
+
+            match caps.name("sign").unwrap() {
+                "<=" => Ok(DaySpec::LastOnOrBefore(weekday, day)),
+                ">=" => Ok(DaySpec::FirstOnOrAfter(weekday, day)),
+                 _   => unreachable!("The regex only matches one of those two!"),
+            }
+        }
+
+        // Otherwise, give up.
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+impl DaySpec {
+
+    /// Converts this day specification to a concrete date, given the year and
+    /// month it should occur in.
+    fn to_concrete_date(&self, year: i64, month: local::Month) -> local::LocalDate {
+        use datetime::local::{LocalDate, Year, DatePiece};
+
+        match *self {
+            DaySpec::Ordinal(day)           => LocalDate::ymd(year, month, day as i8).unwrap(),
+            DaySpec::Last(w)                => DaySpec::find_weekday(w, Year(year).days_for_month(month).rev()),
+            DaySpec::LastOnOrBefore(w, day) => DaySpec::find_weekday(w, Year(year).days_for_month(month).rev().filter(|d| d.day() < day as i8)),
+            DaySpec::FirstOnOrAfter(w, day) => DaySpec::find_weekday(w, Year(year).days_for_month(month).skip(day as usize - 1)),
+        }
+    }
+
+    /// Find the first-occurring day with the given weekday in the iterator.
+    /// Panics if it can't find one. It should find one!
+    fn find_weekday<I>(weekday: WeekdaySpec, mut iterator: I) -> local::LocalDate
+    where I: Iterator<Item=local::LocalDate> {
+        use datetime::local::DatePiece;
+
+        iterator.find(|date| date.weekday() == weekday.0)
+                .expect("Failed to find weekday")
+    }
+}
+
+
+/// A **time** definition field.
+///
+/// A time must have an hours component, with optional minutes and seconds
+/// components. It can also be negative with a starting '-'.
+///
+/// Hour 0 is midnight at the start of the day, and Hour 24 is midnight at the
+/// end of the day.
+///
+/// Additionally, a time may be followed with a letter, signifying what 'type'
+/// of time the timestamp is:
+///
+/// - **w** for "wall clock" time (the default),
+/// - **s** for local standard time,jkdx
+/// - **u** or **g** or **z** for universal time.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum TimeSpec {
+
+    /// A number of hours.
+    Hours(i32),
+
+    /// A number of hours and minutes.
+    HoursMinutes(i32, i32, TimeType),
+
+    /// A number of hours, minutes, and seconds.
+    HoursMinutesSeconds(i32, i32, i32, TimeType),
+
+    /// Zero, or midnight at the start of the day.
+    Zero,
+}
+
+/// The "type" of time that a time is.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum TimeType {
+
+    /// Wall-clock time.
+    Wall,
+
+    /// Standard Time.
+    Standard,
+
+    /// Universal Co-ordinated Time.
+    UTC,
+}
+
+impl FromStr for TimeSpec {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<TimeSpec, Self::Err> {
+
+        if input == "-" {
+            Ok(TimeSpec::Zero)
+        }
+        else if input.chars().all(|c| c == '-' || c.is_digit(10)) {
+            Ok(TimeSpec::Hours(input.parse().unwrap()))
+        }
+        else if let Some(caps) = HM_FIELD.captures(input) {
+            let hour   = caps.name("hour").unwrap().parse().unwrap();
+            let minute = caps.name("minute").unwrap().parse().unwrap();
+            let flag   = caps.name("flag").and_then(|c| TimeType::from_str(&c[0..1]))
+                                          .unwrap_or(TimeType::Wall);
+
+            Ok(TimeSpec::HoursMinutes(hour, minute, flag))
+        }
+        else if let Some(caps) = HMS_FIELD.captures(input) {
+            let hour   = caps.name("hour").unwrap().parse().unwrap();
+            let minute = caps.name("minute").unwrap().parse().unwrap();
+            let second = caps.name("second").unwrap().parse().unwrap();
+            let flag   = caps.name("flag").and_then(|c| TimeType::from_str(&c[0..1]))
+                                          .unwrap_or(TimeType::Wall);
+
+            Ok(TimeSpec::HoursMinutesSeconds(hour, minute, second, flag))
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+impl TimeType {
+    fn from_str(c: &str) -> Option<TimeType> {
+        Some(match c {
+            "w"             => TimeType::Wall,
+            "s"             => TimeType::Standard,
+            "u" | "g" | "z" => TimeType::UTC,
+             _              => return None,
+        })
+    }
+}
+
+
 /// An error that can occur during parsing.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub enum Error {
@@ -503,6 +625,7 @@ pub enum Error {
     Fail
 }
 
+
 /// A type of valid line that has been parsed.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub enum Line<'line> {
@@ -551,104 +674,110 @@ impl<'line> Line<'line> {
 
 #[cfg(test)]
 mod test {
-    use std::str::FromStr;
-
-    use super::*;
-    use datetime::local;
+    pub use std::str::FromStr;
+    pub use super::*;
+    pub use datetime::local;
 
     macro_rules! test {
         ($name:ident: $input:expr => $result:expr) => {
             #[test]
             fn $name() {
-                assert_eq!(Line::from_str($input), Ok($result));
+                assert_eq!(Line::from_str($input), $result);
             }
         };
     }
 
-    test!(empty:    ""           => Line::Space);
-
-    test!(example: "Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D" => Line::Rule(Rule {
-        name:         "US",
-        from_year:    Year::Number(1967),
-        to_year:      Some(Year::Number(1973)),
-        month:        Month(local::Month::April),
-        day:          Day::Last(Weekday(local::Weekday::Sunday)),
-        time_of_day:  Time::HoursMinutes(2, 0, None),
-        time_to_add:  Time::HoursMinutes(1, 0, None),
-        letters:      Some("D"),
-    }));
-
-    test!(example_2: "Rule	Greece	1976	only	-	Oct	10	2:00s	0	-" => Line::Rule(Rule {
-        name:         "Greece",
-        from_year:    Year::Number(1976),
-        to_year:      None,
-        month:        Month(local::Month::October),
-        day:          Day::Ordinal(10),
-        time_of_day:  Time::HoursMinutes(2, 0, Some('s')),
-        time_to_add:  Time::Hours(0),
-        letters:      None,
-    }));
-
-    test!(rule_3: "Rule	EU	1977	1980	-	Apr	Sun>=1	 1:00u	1:00	S" => Line::Rule(Rule {
-        name: "EU",
-        from_year: Year::Number(1977),
-        to_year: Some(Year::Number(1980)),
-        month: Month(local::Month::April),
-        day: Day::LastOnOrAfter(Weekday(local::Weekday::Sunday), 1),
-        time_of_day: Time::HoursMinutes(1, 0, Some('u')),
-        time_to_add: Time::HoursMinutes(1, 0, None),
-        letters:     Some("S"),
-    }));
-
-    test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Line::Zone(Zone {
-        name: "Australia/Adelaide",
-        info: ZoneInfo {
-            gmt_offset:  Time::HoursMinutes(9, 30, None),
+    test!(empty:    ""          => Ok(Line::Space));
+    test!(spaces:   "        "  => Ok(Line::Space));
+
+    mod rules {
+        use super::*;
+
+        test!(rule_1: "Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D" => Ok(Line::Rule(Rule {
+            name:         "US",
+            from_year:    YearSpec::Number(1967),
+            to_year:      Some(YearSpec::Number(1973)),
+            month:        MonthSpec(local::Month::April),
+            day:          DaySpec::Last(WeekdaySpec(local::Weekday::Sunday)),
+            time_of_day:  TimeSpec::HoursMinutes(2, 0, TimeType::Wall),
+            time_to_add:  TimeSpec::HoursMinutes(1, 0, TimeType::Wall),
+            letters:      Some("D"),
+        })));
+
+        test!(rule_2: "Rule	Greece	1976	only	-	Oct	10	2:00s	0	-" => Ok(Line::Rule(Rule {
+            name:         "Greece",
+            from_year:    YearSpec::Number(1976),
+            to_year:      None,
+            month:        MonthSpec(local::Month::October),
+            day:          DaySpec::Ordinal(10),
+            time_of_day:  TimeSpec::HoursMinutes(2, 0, TimeType::Standard),
+            time_to_add:  TimeSpec::Hours(0),
+            letters:      None,
+        })));
+
+        test!(rule_3: "Rule	EU	1977	1980	-	Apr	Sun>=1	 1:00u	1:00	S" => Ok(Line::Rule(Rule {
+            name: "EU",
+            from_year: YearSpec::Number(1977),
+            to_year: Some(YearSpec::Number(1980)),
+            month: MonthSpec(local::Month::April),
+            day: DaySpec::FirstOnOrAfter(WeekdaySpec(local::Weekday::Sunday), 1),
+            time_of_day: TimeSpec::HoursMinutes(1, 0, TimeType::UTC),
+            time_to_add: TimeSpec::HoursMinutes(1, 0, TimeType::Wall),
+            letters:     Some("S"),
+        })));
+
+        test!(no_hyphen: "Rule	EU	1977	1980	HEY	Apr	Sun>=1	 1:00u	1:00	S"         => Err(Error::Fail));
+        test!(bad_month: "Rule	EU	1977	1980	-	Febtober	Sun>=1	 1:00u	1:00	S" => Err(Error::Fail));
+    }
+
+    mod zones {
+        use super::*;
+
+        test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Ok(Line::Zone(Zone {
+            name: "Australia/Adelaide",
+            info: ZoneInfo {
+                gmt_offset:  TimeSpec::HoursMinutes(9, 30, TimeType::Wall),
+                rules_save:  RulesSave::Rules("Aus"),
+                format:      "AC%sT",
+                time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0, TimeType::Wall))),
+            },
+        })));
+
+        test!(continuation_1: "                          9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Ok(Line::Continuation(ZoneInfo {
+            gmt_offset:  TimeSpec::HoursMinutes(9, 30, TimeType::Wall),
             rules_save:  RulesSave::Rules("Aus"),
             format:      "AC%sT",
-            time:        Some(ZoneTime::UntilTime(Year::Number(1971), Month(local::Month::October), Day::Ordinal(31), Time::HoursMinutesSeconds(2, 0, 0, None))),
-        },
-    }));
-
-    test!(continuation: "                          9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Line::Continuation(ZoneInfo {
-        gmt_offset:  Time::HoursMinutes(9, 30, None),
-        rules_save:  RulesSave::Rules("Aus"),
-        format:      "AC%sT",
-        time:        Some(ZoneTime::UntilTime(Year::Number(1971), Month(local::Month::October), Day::Ordinal(31), Time::HoursMinutesSeconds(2, 0, 0, None))),
-    }));
-
-    test!(link: "Link  Europe/Istanbul  Asia/Istanbul" => Line::Link(Link {
+            time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0, TimeType::Wall))),
+        })));
+
+        test!(continuation_2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Ok(Line::Continuation(ZoneInfo {
+            gmt_offset:  TimeSpec::HoursMinutes(1, 00, TimeType::Wall),
+            rules_save:  RulesSave::Rules("C-Eur"),
+            format:      "CE%sT",
+            time:        Some(ZoneTime::UntilDay(YearSpec::Number(1943), MonthSpec(local::Month::October), DaySpec::Ordinal(25))),
+        })));
+
+        test!(zone_hyphen: "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919" => Ok(Line::Zone(Zone {
+            name: "Asia/Ust-Nera",
+            info: ZoneInfo {
+                gmt_offset:  TimeSpec::HoursMinutesSeconds(9, 32, 54, TimeType::Wall),
+                rules_save:  RulesSave::Neither,
+                format:      "LMT",
+                time:        Some(ZoneTime::UntilYear(YearSpec::Number(1919))),
+            },
+        })));
+    }
+
+    test!(link: "Link  Europe/Istanbul  Asia/Istanbul" => Ok(Line::Link(Link {
         existing:  "Europe/Istanbul",
         new:       "Asia/Istanbul",
-    }));
-
-    test!(continuatio2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Line::Continuation(ZoneInfo {
-        gmt_offset:  Time::HoursMinutes(1, 00, None),
-        rules_save:  RulesSave::Rules("C-Eur"),
-        format:      "CE%sT",
-        time:        Some(ZoneTime::UntilDay(Year::Number(1943), Month(local::Month::October), Day::Ordinal(25))),
-    }));
-
-    test!(zone_hyphen: "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919" => Line::Zone(Zone {
-        name: "Asia/Ust-Nera",
-        info: ZoneInfo {
-            gmt_offset:  Time::HoursMinutesSeconds(9, 32, 54, None),
-            rules_save:  RulesSave::Neither,
-            format:      "LMT",
-            time:        Some(ZoneTime::UntilYear(Year::Number(1919))),
-        },
-    }));
-
-    /// "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919 Dec 15"
+    })));
 
     #[test]
     fn month() {
-        assert_eq!(Month::from_str("Aug"), Ok(Month(local::Month::August)));
-        assert_eq!(Month::from_str("December"), Ok(Month(local::Month::December)));
+        assert_eq!(MonthSpec::from_str("Aug"), Ok(MonthSpec(local::Month::August)));
+        assert_eq!(MonthSpec::from_str("December"), Ok(MonthSpec(local::Month::December)));
     }
 
-    #[test]
-    fn golb() {
-        assert!(Line::from_str("GOLB").is_err());
-    }
+    test!(golb: "GOLB" => Err(Error::Fail));
 }

From 6c50d766f34b9ec6900e290a112b7ba5b878cb5b Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sun, 27 Sep 2015 19:22:30 +0100
Subject: [PATCH 007/113] Badges badges badges

---
 README.md | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 README.md

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..f6cd93d
--- /dev/null
+++ b/README.md
@@ -0,0 +1,3 @@
+# olson-parse [![Build status](https://travis-ci.org/rust-datetime/olson-parse.svg)](https://travis-ci.org/rust-datetime/olson-parse) [![Coverage status](https://coveralls.io/repos/rust-datetime/olson-parse/badge.svg?branch=master&service=github)](https://coveralls.io/github/rust-datetime/olson-parse?branch=master)
+
+Rust library for reading [Time Zone database](https://github.com/eggert/tz) files.

From 5a05c647194e2e110fde093f79ab5979b5ef7b3f Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 1 Oct 2015 15:46:13 +0100
Subject: [PATCH 008/113] Separate time specs and their types

Not all time specs need to have a time type associated with them - only one particular kind. This commit mandates that, by removing the type from the struct.

Also, rename RulesSave to Saving, which is what it's being called everywhere else.
---
 src/line.rs | 166 ++++++++++++++++++++++++++--------------------------
 1 file changed, 84 insertions(+), 82 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index f36c55a..6c5098f 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -113,7 +113,7 @@ pub struct Rule<'line> {
     pub day: DaySpec,
 
     /// The time of day at which the rule takes effect.
-    pub time_of_day: TimeSpec,
+    pub time: TimeSpecAndType,
 
     /// The amount of time to be added when the rule is in effect.
     pub time_to_add: TimeSpec,
@@ -149,7 +149,7 @@ impl<'line> Rule<'line> {
 
             let month         = try!(caps.name("in").unwrap().parse());
             let day           = try!(caps.name("on").unwrap().parse());
-            let time_of_day   = try!(caps.name("at").unwrap().parse());
+            let time          = try!(caps.name("at").unwrap().parse());
             let time_to_add   = try!(caps.name("save").unwrap().parse());
             let letters       = match caps.name("letters").unwrap() {
                 "-"  => None,
@@ -162,7 +162,7 @@ impl<'line> Rule<'line> {
                 to_year:      to_year,
                 month:        month,
                 day:          day,
-                time_of_day:  time_of_day,
+                time:         time,
                 time_to_add:  time_to_add,
                 letters:      letters,
             })
@@ -212,7 +212,7 @@ pub struct ZoneInfo<'line> {
 
     /// The name of all the rules that should apply in the time zone, or the
     /// amount of time to add.
-    pub rules_save: RulesSave<'line>,
+    pub saving: Saving<'line>,
 
     /// The format for time zone abbreviations, with `%s` as the string marker.
     pub format: &'line str,
@@ -241,7 +241,7 @@ impl<'line> Zone<'line> {
 impl<'line> ZoneInfo<'line> {
     fn from_captures(caps: Captures<'line>) -> Result<ZoneInfo<'line>, Error> {
         let gmt_offset    = try!(caps.name("gmtoff").unwrap().parse());
-        let rules_save    = try!(RulesSave::from_str(caps.name("rulessave").unwrap()));
+        let saving        = try!(Saving::from_str(caps.name("rulessave").unwrap()));
         let format        = caps.name("format").unwrap();
 
         // The year, month, day, and time fields are all optional, meaning
@@ -258,7 +258,7 @@ impl<'line> ZoneInfo<'line> {
 
         Ok(ZoneInfo {
             gmt_offset:  gmt_offset,
-            rules_save:  rules_save,
+            saving:      saving,
             format:      format,
             time:        time,
         })
@@ -266,31 +266,36 @@ impl<'line> ZoneInfo<'line> {
 }
 
 
-/// A specific type for a certain Zone column.
+/// The amount of daylight saving time (DST) to apply to this timespan. This
+/// is a special type for a certain field in a zone line, which can hold
+/// different types of value.
 #[derive(PartialEq, Debug, Copy, Clone)]
-pub enum RulesSave<'line> {
+pub enum Saving<'line> {
 
-    /// The name of the **rules** to apply.
-    Rules(&'line str),
+    /// Just stick to the base offset.
+    NoSaving,
 
-    /// The amount of **save** time to add.
-    Save(TimeSpec),
+    /// This amount of time should be saved while this timespan is in effect.
+    /// (This is the equivalent to there being a single one-off rule with the
+    /// given amount of time to save).
+    OneOff(TimeSpec),
 
-    /// Neither of these were specified.
-    Neither,
+    /// All rules with the given name should apply while this timespan is in
+    /// effect.
+    Multiple(&'line str),
 }
 
-impl<'line> RulesSave<'line> {
-    fn from_str(input: &str) -> Result<RulesSave, Error> {
+impl<'line> Saving<'line> {
+    fn from_str(input: &str) -> Result<Saving, Error> {
         if input == "-" {
-            Ok(RulesSave::Neither)
+            Ok(Saving::NoSaving)
         }
         else if input.chars().all(|c| c == '-' || c == '_' || c.is_alphabetic()) {
-            Ok(RulesSave::Rules(input))
+            Ok(Saving::Multiple(input))
         }
         else if HM_FIELD.is_match(input) {
             let time = try!(input.parse());
-            Ok(RulesSave::Save(time))
+            Ok(Saving::OneOff(time))
         }
         else {
             Err(Error::Fail)
@@ -314,7 +319,7 @@ pub enum ZoneTime {
 
     /// The earliest point in a particular hour, minute, or second, or one of
     /// those small time units, anyway.
-    UntilTime(YearSpec, MonthSpec, DaySpec, TimeSpec),
+    UntilTime(YearSpec, MonthSpec, DaySpec, TimeSpecAndType),
 }
 
 
@@ -500,32 +505,6 @@ impl FromStr for DaySpec {
     }
 }
 
-impl DaySpec {
-
-    /// Converts this day specification to a concrete date, given the year and
-    /// month it should occur in.
-    fn to_concrete_date(&self, year: i64, month: local::Month) -> local::LocalDate {
-        use datetime::local::{LocalDate, Year, DatePiece};
-
-        match *self {
-            DaySpec::Ordinal(day)           => LocalDate::ymd(year, month, day as i8).unwrap(),
-            DaySpec::Last(w)                => DaySpec::find_weekday(w, Year(year).days_for_month(month).rev()),
-            DaySpec::LastOnOrBefore(w, day) => DaySpec::find_weekday(w, Year(year).days_for_month(month).rev().filter(|d| d.day() < day as i8)),
-            DaySpec::FirstOnOrAfter(w, day) => DaySpec::find_weekday(w, Year(year).days_for_month(month).skip(day as usize - 1)),
-        }
-    }
-
-    /// Find the first-occurring day with the given weekday in the iterator.
-    /// Panics if it can't find one. It should find one!
-    fn find_weekday<I>(weekday: WeekdaySpec, mut iterator: I) -> local::LocalDate
-    where I: Iterator<Item=local::LocalDate> {
-        use datetime::local::DatePiece;
-
-        iterator.find(|date| date.weekday() == weekday.0)
-                .expect("Failed to find weekday")
-    }
-}
-
 
 /// A **time** definition field.
 ///
@@ -535,12 +514,6 @@ impl DaySpec {
 /// Hour 0 is midnight at the start of the day, and Hour 24 is midnight at the
 /// end of the day.
 ///
-/// Additionally, a time may be followed with a letter, signifying what 'type'
-/// of time the timestamp is:
-///
-/// - **w** for "wall clock" time (the default),
-/// - **s** for local standard time,jkdx
-/// - **u** or **g** or **z** for universal time.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub enum TimeSpec {
 
@@ -548,16 +521,23 @@ pub enum TimeSpec {
     Hours(i32),
 
     /// A number of hours and minutes.
-    HoursMinutes(i32, i32, TimeType),
+    HoursMinutes(i32, i32),
 
     /// A number of hours, minutes, and seconds.
-    HoursMinutesSeconds(i32, i32, i32, TimeType),
+    HoursMinutesSeconds(i32, i32, i32),
 
     /// Zero, or midnight at the start of the day.
     Zero,
 }
 
 /// The "type" of time that a time is.
+///
+/// A time may be followed with a letter, signifying what 'type'
+/// of time the timestamp is:
+///
+/// - **w** for "wall clock" time (the default),
+/// - **s** for local standard time,jkdx
+/// - **u** or **g** or **z** for universal time.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub enum TimeType {
 
@@ -571,16 +551,26 @@ pub enum TimeType {
     UTC,
 }
 
-impl FromStr for TimeSpec {
-    type Err = Error;
+/// A time spec *and* a time type. Certain fields need to have both.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct TimeSpecAndType(pub TimeSpec, pub TimeType);
 
-    fn from_str(input: &str) -> Result<TimeSpec, Self::Err> {
+#[cfg(test)]
+impl TimeSpec {
+    fn with_type(self, time_type: TimeType) -> TimeSpecAndType {
+        TimeSpecAndType(self, time_type)
+    }
+}
+
+impl FromStr for TimeSpecAndType {
+    type Err = Error;
 
+    fn from_str(input: &str) -> Result<TimeSpecAndType, Self::Err> {
         if input == "-" {
-            Ok(TimeSpec::Zero)
+            Ok(TimeSpecAndType(TimeSpec::Zero, TimeType::Wall))
         }
         else if input.chars().all(|c| c == '-' || c.is_digit(10)) {
-            Ok(TimeSpec::Hours(input.parse().unwrap()))
+            Ok(TimeSpecAndType(TimeSpec::Hours(input.parse().unwrap()), TimeType::Wall))
         }
         else if let Some(caps) = HM_FIELD.captures(input) {
             let hour   = caps.name("hour").unwrap().parse().unwrap();
@@ -588,7 +578,7 @@ impl FromStr for TimeSpec {
             let flag   = caps.name("flag").and_then(|c| TimeType::from_str(&c[0..1]))
                                           .unwrap_or(TimeType::Wall);
 
-            Ok(TimeSpec::HoursMinutes(hour, minute, flag))
+            Ok(TimeSpecAndType(TimeSpec::HoursMinutes(hour, minute), flag))
         }
         else if let Some(caps) = HMS_FIELD.captures(input) {
             let hour   = caps.name("hour").unwrap().parse().unwrap();
@@ -597,7 +587,7 @@ impl FromStr for TimeSpec {
             let flag   = caps.name("flag").and_then(|c| TimeType::from_str(&c[0..1]))
                                           .unwrap_or(TimeType::Wall);
 
-            Ok(TimeSpec::HoursMinutesSeconds(hour, minute, second, flag))
+            Ok(TimeSpecAndType(TimeSpec::HoursMinutesSeconds(hour, minute, second), flag))
         }
         else {
             Err(Error::Fail)
@@ -605,6 +595,18 @@ impl FromStr for TimeSpec {
     }
 }
 
+impl FromStr for TimeSpec {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<TimeSpec, Self::Err> {
+        match input.parse() {
+            Ok(TimeSpecAndType(spec, TimeType::Wall)) => Ok(spec),
+            Ok(TimeSpecAndType(_   , _             )) => Err(Error::Fail),
+            Err(e)                                    => Err(e),
+        }
+    }
+}
+
 impl TimeType {
     fn from_str(c: &str) -> Option<TimeType> {
         Some(match c {
@@ -699,8 +701,8 @@ mod test {
             to_year:      Some(YearSpec::Number(1973)),
             month:        MonthSpec(local::Month::April),
             day:          DaySpec::Last(WeekdaySpec(local::Weekday::Sunday)),
-            time_of_day:  TimeSpec::HoursMinutes(2, 0, TimeType::Wall),
-            time_to_add:  TimeSpec::HoursMinutes(1, 0, TimeType::Wall),
+            time:         TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall),
+            time_to_add:  TimeSpec::HoursMinutes(1, 0),
             letters:      Some("D"),
         })));
 
@@ -710,20 +712,20 @@ mod test {
             to_year:      None,
             month:        MonthSpec(local::Month::October),
             day:          DaySpec::Ordinal(10),
-            time_of_day:  TimeSpec::HoursMinutes(2, 0, TimeType::Standard),
+            time:         TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Standard),
             time_to_add:  TimeSpec::Hours(0),
             letters:      None,
         })));
 
         test!(rule_3: "Rule	EU	1977	1980	-	Apr	Sun>=1	 1:00u	1:00	S" => Ok(Line::Rule(Rule {
-            name: "EU",
-            from_year: YearSpec::Number(1977),
-            to_year: Some(YearSpec::Number(1980)),
-            month: MonthSpec(local::Month::April),
-            day: DaySpec::FirstOnOrAfter(WeekdaySpec(local::Weekday::Sunday), 1),
-            time_of_day: TimeSpec::HoursMinutes(1, 0, TimeType::UTC),
-            time_to_add: TimeSpec::HoursMinutes(1, 0, TimeType::Wall),
-            letters:     Some("S"),
+            name:        "EU",
+            from_year:    YearSpec::Number(1977),
+            to_year:      Some(YearSpec::Number(1980)),
+            month:        MonthSpec(local::Month::April),
+            day:          DaySpec::FirstOnOrAfter(WeekdaySpec(local::Weekday::Sunday), 1),
+            time:         TimeSpec::HoursMinutes(1, 0).with_type(TimeType::UTC),
+            time_to_add:  TimeSpec::HoursMinutes(1, 0),
+            letters:      Some("S"),
         })));
 
         test!(no_hyphen: "Rule	EU	1977	1980	HEY	Apr	Sun>=1	 1:00u	1:00	S"         => Err(Error::Fail));
@@ -736,23 +738,23 @@ mod test {
         test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Ok(Line::Zone(Zone {
             name: "Australia/Adelaide",
             info: ZoneInfo {
-                gmt_offset:  TimeSpec::HoursMinutes(9, 30, TimeType::Wall),
-                rules_save:  RulesSave::Rules("Aus"),
+                gmt_offset:  TimeSpec::HoursMinutes(9, 30),
+                saving:      Saving::Multiple("Aus"),
                 format:      "AC%sT",
-                time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0, TimeType::Wall))),
+                time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0))),
             },
         })));
 
         test!(continuation_1: "                          9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Ok(Line::Continuation(ZoneInfo {
-            gmt_offset:  TimeSpec::HoursMinutes(9, 30, TimeType::Wall),
-            rules_save:  RulesSave::Rules("Aus"),
+            gmt_offset:  TimeSpec::HoursMinutes(9, 30),
+            saving:      Saving::Multiple("Aus"),
             format:      "AC%sT",
-            time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0, TimeType::Wall))),
+            time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0))),
         })));
 
         test!(continuation_2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Ok(Line::Continuation(ZoneInfo {
-            gmt_offset:  TimeSpec::HoursMinutes(1, 00, TimeType::Wall),
-            rules_save:  RulesSave::Rules("C-Eur"),
+            gmt_offset:  TimeSpec::HoursMinutes(1, 00),
+            saving:      Saving::Multiple("C-Eur"),
             format:      "CE%sT",
             time:        Some(ZoneTime::UntilDay(YearSpec::Number(1943), MonthSpec(local::Month::October), DaySpec::Ordinal(25))),
         })));
@@ -760,8 +762,8 @@ mod test {
         test!(zone_hyphen: "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919" => Ok(Line::Zone(Zone {
             name: "Asia/Ust-Nera",
             info: ZoneInfo {
-                gmt_offset:  TimeSpec::HoursMinutesSeconds(9, 32, 54, TimeType::Wall),
-                rules_save:  RulesSave::Neither,
+                gmt_offset:  TimeSpec::HoursMinutesSeconds(9, 32, 54),
+                saving:      Saving::NoSaving,
                 format:      "LMT",
                 time:        Some(ZoneTime::UntilYear(YearSpec::Number(1919))),
             },

From 09179199703ee9f29d14261b0983fe0d4c59ca95 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Tue, 13 Oct 2015 16:42:04 +0100
Subject: [PATCH 009/113] Rename to zoneinfo-parse

---
 Cargo.toml | 2 +-
 README.md  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 45cf7b2..06231a0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "olson-parse"
+name = "zoneinfo_parse"
 version = "0.1.0"
 authors = ["Ben S <ogham@bsago.me>"]
 
diff --git a/README.md b/README.md
index f6cd93d..13a9f7b 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,3 @@
-# olson-parse [![Build status](https://travis-ci.org/rust-datetime/olson-parse.svg)](https://travis-ci.org/rust-datetime/olson-parse) [![Coverage status](https://coveralls.io/repos/rust-datetime/olson-parse/badge.svg?branch=master&service=github)](https://coveralls.io/github/rust-datetime/olson-parse?branch=master)
+# zoneinfo-parse [![Build status](https://travis-ci.org/rust-datetime/zoneinfo-parse.svg)](https://travis-ci.org/rust-datetime/zoneinfo-parse) [![Coverage status](https://coveralls.io/repos/rust-datetime/zoneinfo-parse/badge.svg?branch=master&service=github)](https://coveralls.io/github/rust-datetime/zoneinfo-parse?branch=master)
 
 Rust library for reading [Time Zone database](https://github.com/eggert/tz) files.

From 01b0e42ca0787f685c64c37102f268a3d1a5d695 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Tue, 13 Oct 2015 17:22:35 +0100
Subject: [PATCH 010/113] A program to build the zoneinfo-data crate

---
 Cargo.toml              |   6 +-
 bin/build-data-crate.rs | 226 ++++++++++++++++++++++++++++++++++++++++
 src/lib.rs              |  11 +-
 src/line.rs             |  88 ++++++++++++++--
 src/structure.rs        | 201 +++++++++++++++++++++++++++++++++++
 src/table.rs            | 203 ++++++++++++++++++++++++++++++++++++
 6 files changed, 721 insertions(+), 14 deletions(-)
 create mode 100644 bin/build-data-crate.rs
 create mode 100644 src/structure.rs
 create mode 100644 src/table.rs

diff --git a/Cargo.toml b/Cargo.toml
index 06231a0..91ddd77 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,7 +3,11 @@ name = "zoneinfo_parse"
 version = "0.1.0"
 authors = ["Ben S <ogham@bsago.me>"]
 
+[[bin]]
+name = "build-data-crate"
+path = "bin/build-data-crate.rs"
+
 [dependencies]
 datetime = "*"
 lazy_static = "*"
-regex = "*"
\ No newline at end of file
+regex = "*"
diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
new file mode 100644
index 0000000..8152927
--- /dev/null
+++ b/bin/build-data-crate.rs
@@ -0,0 +1,226 @@
+extern crate zoneinfo_parse;
+use zoneinfo_parse::{Line, TableBuilder, Table, Structure, Child, Saving, ZoneTime};
+
+use std::env::args;
+use std::io::prelude::*;
+use std::io::BufReader;
+use std::io::Result as IoResult;
+use std::fs::{File, OpenOptions, create_dir, metadata};
+use std::path::{Path, PathBuf};
+use std::process::exit;
+
+fn main() {
+    let args: Vec<_> = args().skip(1).collect();
+
+    // let base_path = "~/Code/datetime/zoneinfo-data/src/data";
+    let data_crate = match DataCrate::new(&args[0], &args[1..]) {
+        Ok(dc) => dc,
+        Err(_) => {
+            println!("Errors occurred - not going any further.");
+            exit(1);
+        },
+    };
+
+    match data_crate.run() {
+        Ok(()) => println!("All done."),
+        Err(e) => {
+            println!("IO error: {}", e);
+            exit(1);
+        },
+    }
+}
+
+struct DataCrate {
+    base_path: PathBuf,
+    table: Table,
+}
+
+impl DataCrate {
+
+    fn new<P>(base_path: P, input_file_paths: &[String]) -> Result<DataCrate, u32>
+    where P: Into<PathBuf> {
+
+        let mut builder = TableBuilder::new();
+        let mut errors = 0;
+
+        for arg in input_file_paths {
+            let f = File::open(arg).unwrap();
+            let reader = BufReader::new(f);
+
+            for line in reader.lines() {
+                let line = line.unwrap();
+
+                // Strip out the comment portion from the line, if any.
+                let line_portion = match line.find('#') {
+                    Some(pos) => &line[..pos],
+                    None      => &line[..],
+                };
+
+                let result = match Line::from_str(line_portion) {
+
+                    // If there's an error, then display which line failed to parse.
+                    Err(_) => {
+                        println!("Failed to parse line: {:?}", line_portion);
+                        errors += 1;
+                        continue;
+                    },
+
+                    // Ignore any spaces
+                    Ok(Line::Space) => { continue },
+
+                    Ok(Line::Rule(rule))         => builder.add_rule_line(rule),
+                    Ok(Line::Link(link))         => builder.add_link_line(link),
+                    Ok(Line::Zone(zone))         => builder.add_zone_line(zone),
+                    Ok(Line::Continuation(cont)) => builder.add_continuation_line(cont),
+                };
+
+                if let Err(e) = result {
+                    errors += 1;
+                    println!("Error: {:?}", e);
+                }
+            }
+        }
+
+        if errors == 0 {
+            Ok(DataCrate {
+                base_path: base_path.into(),
+                table: builder.build()
+            })
+        }
+        else {
+            Err(errors)
+        }
+    }
+
+    fn run(&self) -> IoResult<()> {
+        try!(self.write_rulesets());
+        try!(self.create_structure_directories());
+        try!(self.write_zonesets());
+        Ok(())
+    }
+
+    fn write_rulesets(&self) -> IoResult<()> {
+        let path = self.base_path.join("rulesets.rs");
+        let mut w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(path));
+        try!(writeln!(w, "{}", WARNING_HEADER));
+        try!(writeln!(w, "{}", RULESETS_HEADER));
+
+        for (name, ruleset) in &self.table.rulesets {
+            try!(writeln!(w, "pub const {}: Ruleset<'static> = Ruleset {{ rules: &[", name.replace("-", "_")));
+            for rule in &ruleset.0 {
+                try!(writeln!(w, "    {:?},", rule));
+            }
+            try!(writeln!(w, "] }};\n\n"));
+        }
+
+        Ok(())
+    }
+
+    fn create_structure_directories(&self) -> IoResult<()> {
+        let base_mod_path = self.base_path.join("mod.rs");
+        let mut base_w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(base_mod_path));
+        try!(write!(base_w, "pub mod rulesets;\n"));
+
+        for entry in self.table.structure() {
+            if !entry.name.contains('/') {
+                try!(writeln!(base_w, "pub mod {};", entry.name));
+            }
+
+            let components: PathBuf = entry.name.split('/').collect();
+            let dir_path = self.base_path.join(components);
+            if !is_directory(&dir_path) {
+                println!("Creating directory {:?}", &dir_path);
+                try!(create_dir(&dir_path));
+            }
+
+            let mod_path = dir_path.join("mod.rs");
+            let mut w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(mod_path));
+            for child in &entry.children {
+                match *child {
+                    Child::Ruleset(ref name) => {
+                        let sanichild = sanitise_name(name);
+                        try!(writeln!(w, "mod {};", sanichild));
+                        try!(writeln!(w, "pub use self::{}::ZONE as {};\n", sanichild, sanichild));
+                    },
+                    Child::Submodule(ref name) => {
+                        let sanichild = sanitise_name(name);
+                        try!(writeln!(w, "pub mod {};\n", sanichild));
+                    },
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn write_zonesets(&self) -> IoResult<()> {
+        for (name, zoneset) in &self.table.zonesets {
+            let components: PathBuf = name.split('/').map(sanitise_name).collect();
+            let zoneset_path = self.base_path.join(components).with_extension("rs");
+            let mut w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(zoneset_path));
+            try!(writeln!(w, "{}", WARNING_HEADER));
+            try!(writeln!(w, "{}", ZONESETS_HEADER));
+
+            try!(writeln!(w, "pub const ZONE: Zone<'static> = Zone {{"));
+            try!(writeln!(w, "    name: {:?},", name));
+            try!(writeln!(w, "    timespans: &["));
+
+            let mut last_end_time: Option<ZoneTime> = None;
+            for info in &zoneset.0 {
+                let saving = match info.saving {
+                    Saving::NoSaving         => "Saving::NoSaving".to_owned(),
+                    Saving::OneOff(by)       => format!("Saving::OneOff({})", by),
+                    Saving::Multiple(ref n)  => format!("Saving::Multiple(&rulesets::{})", sanitise_name(n)),
+                };
+
+                try!(writeln!(w, "        Timespan {{"));
+                try!(writeln!(w, "            offset: {:?},", info.gmt_offset));
+                try!(writeln!(w, "            format: {:?},", info.format));
+                try!(writeln!(w, "            saving: {},", saving));
+                try!(writeln!(w, "            start_time: {:?},", last_end_time.map(|s| s.to_timestamp())));
+                try!(writeln!(w, "            end_time:   {:?},", info.until.map(|s| s.to_timestamp())));
+                try!(writeln!(w, "        }},"));
+
+                last_end_time = info.until;
+            }
+            try!(writeln!(w, "    ],"));
+            try!(writeln!(w, "}};\n\n"));
+        }
+
+        Ok(())
+    }
+}
+
+fn is_directory(path: &Path) -> bool {
+    match metadata(path) {
+        Ok(m)  => m.is_dir(),
+        Err(_) => false,
+    }
+}
+
+fn sanitise_name(name: &str) -> String {
+    name.replace("-", "_")
+}
+
+const WARNING_HEADER: &'static str = r##"
+// ------
+// This file is autogenerated!
+// Any changes you make may be overwritten.
+// ------
+"##;
+
+const RULESETS_HEADER: &'static str = r##"
+use code::*;
+use code::YearSpec::*;
+use code::DaySpec::*;
+use datetime::local::Month::*;
+use datetime::local::Weekday::*;
+"##;
+
+const ZONESETS_HEADER: &'static str = r##"
+use code::*;
+use code::Saving::*;
+
+#[allow(unused_imports)]
+use data::rulesets;
+"##;
diff --git a/src/lib.rs b/src/lib.rs
index 737f2a0..ad72367 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,7 +2,7 @@
 
 #![warn(missing_copy_implementations)]
 #![warn(missing_debug_implementations)]
-#![warn(missing_docs)]
+//#![warn(missing_docs)]
 #![warn(trivial_casts, trivial_numeric_casts)]
 #![warn(unused_qualifications)]
 #![warn(unused_results)]
@@ -12,4 +12,11 @@ extern crate regex;
 #[macro_use] extern crate lazy_static;
 
 mod line;
-pub use line::*;
+pub use line::{Line, ZoneTime};
+// ^ ZoneTime needs to be here, otherwise you get a linker error (weird!)
+
+mod table;
+pub use table::{Table, TableBuilder, Saving};
+
+mod structure;
+pub use structure::*;
\ No newline at end of file
diff --git a/src/line.rs b/src/line.rs
index 6c5098f..aac02bf 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -1,7 +1,7 @@
 use std::ascii::AsciiExt;
 use std::str::FromStr;
 
-use datetime::local;
+use datetime::local::{self, LocalDate, LocalTime, LocalDateTime};
 
 use regex::{Regex, Captures};
 
@@ -322,6 +322,34 @@ pub enum ZoneTime {
     UntilTime(YearSpec, MonthSpec, DaySpec, TimeSpecAndType),
 }
 
+impl ZoneTime {
+    pub fn to_timestamp(&self) -> i64 {
+        use self::ZoneTime::*;
+        use self::YearSpec::Number;
+        use self::DaySpec::Ordinal;
+        use self::TimeSpec::*;
+
+        match *self {
+            UntilYear(Number(y))       => LocalDateTime::new(LocalDate::ymd(y, local::Month::January, 1).unwrap(), LocalTime::midnight()),
+            UntilMonth(Number(y), m)   => LocalDateTime::new(LocalDate::ymd(y, m.0, 1).unwrap(),                   LocalTime::midnight()),
+            UntilDay(Number(y), m, d)  => LocalDateTime::new(d.to_concrete_date(y, m.0),                           LocalTime::midnight()),
+
+            UntilTime(Number(y), m, d, time) => {
+                let local_time = match time.0 {
+                    Zero                          => LocalTime::midnight(),
+                    Hours(h)                      => LocalTime::hms(h, 0, 0).unwrap(),
+                    HoursMinutes(h, mm)           => LocalTime::hms(h, mm, 0).unwrap(),
+                    HoursMinutesSeconds(h, mm, s) => LocalTime::hms(h, mm, s).unwrap(),
+                };
+
+                LocalDateTime::new(d.to_concrete_date(y, m.0), local_time)
+            },
+
+            _ => unreachable!("What happened? {:?}", self),
+        }.to_instant().seconds()
+    }
+}
+
 
 /// A **link** definition line.
 #[derive(PartialEq, Debug, Copy, Clone)]
@@ -367,7 +395,7 @@ pub enum YearSpec {
     Maximum,
 
     /// A specific year number.
-    Number(i32),
+    Number(i64),
 }
 
 impl FromStr for YearSpec {
@@ -455,18 +483,44 @@ impl FromStr for WeekdaySpec {
 pub enum DaySpec {
 
     /// A specific day of the month, given by its number.
-    Ordinal(i32),
+    Ordinal(i8),
 
     /// The last day of the month with a specific weekday.
     Last(WeekdaySpec),
 
     /// The **last** day with the given weekday **before** (or including) a
     /// day with a specific number.
-    LastOnOrBefore(WeekdaySpec, i32),
+    LastOnOrBefore(WeekdaySpec, i8),
 
     /// The **first** day with the given weekday **after** (or including) a
     /// day with a specific number.
-    FirstOnOrAfter(WeekdaySpec, i32)
+    FirstOnOrAfter(WeekdaySpec, i8)
+}
+
+impl DaySpec {
+
+    /// Converts this day specification to a concrete date, given the year and
+    /// month it should occur in.
+    fn to_concrete_date(&self, year: i64, month: local::Month) -> LocalDate {
+        use datetime::local::{LocalDate, Year, DatePiece};
+
+        match *self {
+            DaySpec::Ordinal(day)           => LocalDate::ymd(year, month, day).unwrap(),
+            DaySpec::Last(w)                => DaySpec::find_weekday(w, Year(year).days_for_month(month).rev()),
+            DaySpec::LastOnOrBefore(w, day) => DaySpec::find_weekday(w, Year(year).days_for_month(month).rev().filter(|d| d.day() < day)),
+            DaySpec::FirstOnOrAfter(w, day) => DaySpec::find_weekday(w, Year(year).days_for_month(month).skip(day as usize - 1)),
+        }
+    }
+
+    /// Find the first-occurring day with the given weekday in the iterator.
+    /// Panics if it can't find one. It should find one!
+    fn find_weekday<I>(weekday: WeekdaySpec, mut iterator: I) -> LocalDate
+    where I: Iterator<Item=LocalDate> {
+        use datetime::local::DatePiece;
+
+        iterator.find(|date| date.weekday() == weekday.0)
+                .expect("Failed to find weekday")
+    }
 }
 
 impl FromStr for DaySpec {
@@ -518,13 +572,13 @@ impl FromStr for DaySpec {
 pub enum TimeSpec {
 
     /// A number of hours.
-    Hours(i32),
+    Hours(i8),
 
     /// A number of hours and minutes.
-    HoursMinutes(i32, i32),
+    HoursMinutes(i8, i8),
 
     /// A number of hours, minutes, and seconds.
-    HoursMinutesSeconds(i32, i32, i32),
+    HoursMinutesSeconds(i8, i8, i8),
 
     /// Zero, or midnight at the start of the day.
     Zero,
@@ -555,11 +609,23 @@ pub enum TimeType {
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub struct TimeSpecAndType(pub TimeSpec, pub TimeType);
 
-#[cfg(test)]
 impl TimeSpec {
+
+    #[cfg(test)]
     fn with_type(self, time_type: TimeType) -> TimeSpecAndType {
         TimeSpecAndType(self, time_type)
     }
+
+    /// Returns the number of seconds past midnight that this time spec
+    /// represents.
+    pub fn as_seconds(&self) -> i64 {
+        match *self {
+            TimeSpec::Zero                         => 0,
+            TimeSpec::Hours(h)                     => h as i64 * 3600,
+            TimeSpec::HoursMinutes(h, m)           => h as i64 * 3600 + m as i64 * 60,
+            TimeSpec::HoursMinutesSeconds(h, m, s) => h as i64 * 3600 + m as i64 * 60 + s as i64,
+        }
+    }
 }
 
 impl FromStr for TimeSpecAndType {
@@ -741,7 +807,7 @@ mod test {
                 gmt_offset:  TimeSpec::HoursMinutes(9, 30),
                 saving:      Saving::Multiple("Aus"),
                 format:      "AC%sT",
-                time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0))),
+                time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
             },
         })));
 
@@ -749,7 +815,7 @@ mod test {
             gmt_offset:  TimeSpec::HoursMinutes(9, 30),
             saving:      Saving::Multiple("Aus"),
             format:      "AC%sT",
-            time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0))),
+            time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
         })));
 
         test!(continuation_2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Ok(Line::Continuation(ZoneInfo {
diff --git a/src/structure.rs b/src/structure.rs
new file mode 100644
index 0000000..23d4021
--- /dev/null
+++ b/src/structure.rs
@@ -0,0 +1,201 @@
+/// Determining the structure of a set of ruleset names.
+///
+/// The names of time zones in the zoneinfo database are of the form
+/// `Area/Location`, or more rarely, `Area/Location/Sublocation`. This means
+/// they form a hierarchy, with each level either serving as a time zone
+/// itself (usually a location) or as a parent of multiple other entries
+/// (usually an area).
+///
+/// When generating Rust code containing the timezone data, we need to
+/// generate the entire tree structure, not just the leaves of actual timezone
+/// data. This module determines that structure, allowing it to be created
+/// before any actual timezone data is written.
+///
+/// For example, say we have the following subset of time zone entries:
+///
+/// - America/Antigua
+/// - America/Araguaina
+/// - America/Argentina/Buenos_Aires
+/// - America/Argentina/Catamarca
+/// - America/Argentina/Cordoba
+/// - America/Aruba
+///
+/// On top of the six actual time zone files, we would need to create the following:
+///
+/// - An America module that has three private submodules (Antigua, Araguaína,
+///   and Aruba) and one public submodule (Argentina);
+/// - An America/Argentina submodule that has there private submodules (Buenos
+///   Aires, Catamarca, Cordoba).
+///
+/// This module contains an iterator that finds all parent zonesets, and
+/// sorts them so they're output in a correct order.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use table::Table;
+
+
+/// Trait to put the `structure` method on Tables.
+pub trait Structure {
+
+    /// The **Structure** of the zonesets.
+    fn structure(&self) -> TableStructure;
+}
+
+impl Structure for Table {
+    fn structure(&self) -> TableStructure {
+        let mut mappings = BTreeMap::new();
+
+        for key in self.zonesets.keys() {
+
+            // Extract the name from the *last* slash. So
+            // `America/Kentucky/Louisville` is split into
+            // `America/Kentucky` and `Louisville` components.
+            let last_slash = match key.rfind('/') {
+                Some(pos) => pos,
+                None      => continue,
+            };
+
+            // Split the string around the slash, which gets removed.
+            let parent = &key[.. last_slash];
+            {
+                let set = mappings.entry(parent).or_insert_with(BTreeSet::new);
+                set.insert(Child::Ruleset(&key[last_slash + 1 ..]));
+            }
+
+            // If the *parent* name still has a slash in it, then this is
+            // a time zone of the form `America/Kentucky/Louisville`. We
+            // need to make sure that `America` now has a `Kentucky`
+            // child, too.
+            if let Some(first_slash) = parent.find('/') {
+                let grandparent = &parent[.. first_slash];
+                let set = mappings.entry(grandparent).or_insert_with(BTreeSet::new);
+                set.insert(Child::Submodule(&parent[first_slash + 1 ..]));
+            }
+        }
+
+        TableStructure { mappings: mappings }
+    }
+}
+
+
+/// The structure of a set of time zone names.
+#[derive(PartialEq, Debug)]
+pub struct TableStructure<'table> {
+    mappings: BTreeMap<&'table str, BTreeSet<Child<'table>>>,
+}
+
+impl<'table> IntoIterator for TableStructure<'table> {
+    type Item = TableStructureEntry<'table>;
+    type IntoIter = Iter<'table>;
+
+    fn into_iter(self) -> Self::IntoIter {
+
+        // It's necessary to sort the keys before producing them, to
+        // ensure that (for example) America is produced before
+        // America/Kentucky.
+        let mut keys: Vec<_> = self.mappings.keys().cloned().collect();
+        keys.sort_by(|a, b| b.cmp(a));
+
+        Iter {
+            structure: self,
+            keys: keys,
+        }
+    }
+}
+
+/// Iterator over sorted entries in a `TableStructure`.
+#[derive(PartialEq, Debug)]
+pub struct Iter<'table> {
+    structure: TableStructure<'table>,
+    keys: Vec<&'table str>,
+}
+
+impl<'table> Iterator for Iter<'table> {
+    type Item = TableStructureEntry<'table>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let key = match self.keys.pop() {
+                Some(k) => k,
+                None    => return None,
+            };
+
+            // Move the strings out into an (automatically-sorted) vector.
+            let values = self.structure.mappings[key].iter()
+                                                     .map(|&s| s)
+                                                     .collect();
+
+            return Some(TableStructureEntry {
+                name: key,
+                children: values,
+            });
+        }
+    }
+}
+
+/// An entry returned from a `TableStructure` iterator.
+#[derive(PartialEq, Debug)]
+pub struct TableStructureEntry<'table> {
+
+    /// This entry's name, which **can** still include slashes.
+    pub name: &'table str,
+
+    /// A vector of sorted child names, which should have no slashes in.
+    pub children: Vec<Child<'table>>,
+}
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Copy, Clone)]
+pub enum Child<'table> {
+    Submodule(&'table str),
+    Ruleset(&'table str),
+}
+
+
+#[cfg(test)]
+#[allow(unused_results)]
+mod test {
+    use super::*;
+    use table::{Table, Zoneset};
+
+    #[test]
+    fn empty() {
+        let table = Table::default();
+        let mut structure = table.structure().into_iter();
+        assert_eq!(structure.next(), None);
+    }
+
+    #[test]
+    fn separate() {
+        let mut table = Table::default();
+        table.zonesets.insert("a".to_owned(), Zoneset::default());
+        table.zonesets.insert("b".to_owned(), Zoneset::default());
+        table.zonesets.insert("c".to_owned(), Zoneset::default());
+
+        let mut structure = table.structure().into_iter();
+        assert_eq!(structure.next(), None);
+    }
+
+    #[test]
+    fn child() {
+        let mut table = Table::default();
+        table.zonesets.insert("a/b".to_owned(), Zoneset::default());
+
+        let mut structure = table.structure().into_iter();
+        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(), children: vec![ Child::Ruleset("b") ] }));
+        assert_eq!(structure.next(), None);
+    }
+
+    #[test]
+    fn hierarchy() {
+        let mut table = Table::default();
+        table.zonesets.insert("a/b/c".to_owned(), Zoneset::default());
+        table.zonesets.insert("a/b/d".to_owned(), Zoneset::default());
+        table.zonesets.insert("a/e".to_owned(),   Zoneset::default());
+
+        let mut structure = table.structure().into_iter();
+        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(),   children: vec![ Child::Submodule("b"), Child::Ruleset("e") ] }));
+        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a/b".to_owned(), children: vec![ Child::Ruleset("c"),   Child::Ruleset("d") ] }));
+        assert_eq!(structure.next(), None);
+    }
+}
diff --git a/src/table.rs b/src/table.rs
new file mode 100644
index 0000000..52d9f72
--- /dev/null
+++ b/src/table.rs
@@ -0,0 +1,203 @@
+use std::collections::hash_map::{HashMap, Entry};
+
+use line::{self, YearSpec, DaySpec, MonthSpec, ZoneTime};
+
+
+/// A table of all the data in one or more zoneinfo files.
+#[derive(PartialEq, Debug, Default)]
+pub struct Table {
+
+    /// Mapping of ruleset names to rulesets.
+    pub rulesets: HashMap<String, Ruleset>,
+
+    /// Mapping of zoneset names to zonesets.
+    pub zonesets: HashMap<String, Zoneset>,
+
+    /// Mapping of link timezone names, to the names they link to.
+    pub links: HashMap<String, String>,
+}
+
+#[derive(PartialEq, Debug, Default)]
+pub struct Ruleset(pub Vec<RuleInfo>);
+
+#[derive(PartialEq, Debug)]
+struct RuleInfo {
+
+    /// The year that this rule *starts* applying.
+    from_year: YearSpec,
+
+    /// The year that this rule *finishes* applying, inclusive, or `None` if
+    /// it applies up until the end of this timespan.
+    to_year: Option<YearSpec>,
+
+    /// The month it applies on.
+    month: MonthSpec,
+
+    /// The day it applies on.
+    day: DaySpec,
+
+    /// The exact time it applies on.
+    time: i64,
+
+    /// The amount of time to save.
+    time_to_add: i64,
+
+    /// Any extra letters that should be added to this time zone's
+    /// abbreviation, in place of `%s`.
+    letters: Option<String>,
+}
+
+impl<'_> From<line::Rule<'_>> for RuleInfo {
+    fn from(info: line::Rule) -> RuleInfo {
+        RuleInfo {
+            from_year:    info.from_year,
+            to_year:      info.to_year,
+            month:        info.month,
+            day:          info.day,
+            time:         info.time.0.as_seconds(),
+            time_to_add:  info.time_to_add.as_seconds(),
+            letters:      info.letters.map(str::to_owned),
+        }
+    }
+}
+
+#[derive(PartialEq, Debug, Default)]
+pub struct Zoneset(pub Vec<ZoneInfo>);
+
+#[derive(PartialEq, Debug)]
+pub struct ZoneInfo {
+    pub gmt_offset: i64,
+    pub format:     String,
+    pub saving:     Saving,
+    pub until:      Option<ZoneTime>,
+}
+
+#[derive(PartialEq, Debug)]
+pub enum Saving {
+    NoSaving,
+    OneOff(i64),
+    Multiple(String),
+}
+
+impl<'_> From<line::ZoneInfo<'_>> for ZoneInfo {
+    fn from(info: line::ZoneInfo) -> ZoneInfo {
+        ZoneInfo {
+            gmt_offset: info.gmt_offset.as_seconds(),
+            saving: match info.saving {
+                line::Saving::NoSaving     => Saving::NoSaving,
+                line::Saving::Multiple(s)  => Saving::Multiple(s.to_owned()),
+                line::Saving::OneOff(t)    => Saving::OneOff(t.as_seconds()),
+            },
+            format: info.format.to_owned(),
+            until: info.time,
+        }
+    }
+}
+
+
+/// A builder for `Table` values based on various line definitions.
+#[derive(PartialEq, Debug)]
+pub struct TableBuilder {
+
+    /// The table that's being built up.
+    table: Table,
+
+    /// If the last line was a zone definition, then this holds its name.
+    /// `None` otherwise. This is so continuation lines can be added to the
+    /// same zone as the original zone line.
+    current_zoneset_name: Option<String>,
+}
+
+impl TableBuilder {
+
+    /// Creates a new builder with an empty table.
+    pub fn new() -> TableBuilder {
+        TableBuilder {
+            table: Table::default(),
+            current_zoneset_name: None,
+        }
+    }
+
+    /// Adds a new line describing a zone definition.
+    ///
+    /// Returns an error if there's already a zone with the same name, or the
+    /// zone refers to a ruleset that hasn't been defined yet.
+    pub fn add_zone_line<'line>(&mut self, zone_line: line::Zone<'line>) -> Result<(), Error<'line>> {
+        if let line::Saving::Multiple(ruleset_name) = zone_line.info.saving {
+            if !self.table.rulesets.contains_key(ruleset_name) {
+                return Err(Error::UnknownRuleset(ruleset_name));
+            }
+        }
+
+        let mut zoneset = match self.table.zonesets.entry(zone_line.name.to_owned()) {
+            Entry::Occupied(_)  => return Err(Error::DuplicateZone),
+            Entry::Vacant(e)    => e.insert(Zoneset(Vec::new())),
+        };
+
+        let _ = zoneset.0.push(zone_line.info.into());
+        self.current_zoneset_name = Some(zone_line.name.to_owned());
+        Ok(())
+    }
+
+    /// Adds a new line describing the *continuation* of a zone definition.
+    ///
+    /// Returns an error if the builder wasn't expecting a continuation line
+    /// (meaning, the previous line wasn't a zone line)
+    pub fn add_continuation_line(&mut self, continuation_line: line::ZoneInfo) -> Result<(), Error> {
+        let mut zoneset = match self.current_zoneset_name {
+            Some(ref name) => self.table.zonesets.get_mut(name).unwrap(),
+            None => return Err(Error::SurpriseContinuationLine),
+        };
+
+        let _ = zoneset.0.push(continuation_line.into());
+        Ok(())
+    }
+
+    /// Adds a new line describing one entry in a ruleset, creating that set
+    /// if it didn't exist already.
+    pub fn add_rule_line(&mut self, rule_line: line::Rule) -> Result<(), Error> {
+        let ruleset = self.table.rulesets
+                                .entry(rule_line.name.to_owned())
+                                .or_insert_with(|| Ruleset(Vec::new()));
+
+        ruleset.0.push(rule_line.into());
+        self.current_zoneset_name = None;
+        Ok(())
+    }
+
+    /// Adds a new line linking one zone to another.
+    ///
+    /// Returns an error if there was already a link with that name.
+    pub fn add_link_line<'line>(&mut self, link_line: line::Link<'line>) -> Result<(), Error<'line>> {
+        match self.table.links.entry(link_line.new.to_owned()) {
+            Entry::Occupied(_)  => Err(Error::DuplicateLink(link_line.new)),
+            Entry::Vacant(e)    => {
+                let _ = e.insert(link_line.existing.to_owned());
+                self.current_zoneset_name = None;
+                Ok(())
+            }
+        }
+    }
+
+    /// Returns the table after it's finished being built.
+    pub fn build(self) -> Table {
+        self.table
+    }
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Error<'line> {
+
+    /// A continuation line was passed in, but the previous line wasn't a zone
+    /// definition line.
+    SurpriseContinuationLine,
+
+    /// A zone definition referred to a ruleset that hadn't been defined.
+    UnknownRuleset(&'line str),
+
+    /// A link line was passed in, but there's already a link with that name.
+    DuplicateLink(&'line str),
+
+    /// A zone line was passed in, but there's already a zone with that name.
+    DuplicateZone,
+}
\ No newline at end of file

From 65a9d154fe167bec2adfb8debe642234b6d77029 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Tue, 27 Oct 2015 10:01:07 +0000
Subject: [PATCH 011/113] Add proper transition calculation

This code uses an algorithm cribbed from the C examples in the tzinfo database itself, so they're actually more correct than whatever I was using!

- Rename GMT to UTC wherever it's used. It means pretty much the same, but is more modern (I hope this commit message isn't used to make fun of me in the future)
- Use the Time Type enum in datetime - there's no point having two of them.
- Add a lookup function in the data crate.
---
 bin/build-data-crate.rs |  82 ++----
 src/lib.rs              |   2 +
 src/line.rs             |  62 ++---
 src/table.rs            | 548 +++++++++++++++++++++++++++++++++++++++-
 4 files changed, 589 insertions(+), 105 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 8152927..9760be9 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -1,5 +1,5 @@
 extern crate zoneinfo_parse;
-use zoneinfo_parse::{Line, TableBuilder, Table, Structure, Child, Saving, ZoneTime};
+use zoneinfo_parse::{Line, TableBuilder, Table, Structure, Child};
 
 use std::env::args;
 use std::io::prelude::*;
@@ -93,33 +93,16 @@ impl DataCrate {
     }
 
     fn run(&self) -> IoResult<()> {
-        try!(self.write_rulesets());
         try!(self.create_structure_directories());
         try!(self.write_zonesets());
         Ok(())
     }
 
-    fn write_rulesets(&self) -> IoResult<()> {
-        let path = self.base_path.join("rulesets.rs");
-        let mut w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(path));
-        try!(writeln!(w, "{}", WARNING_HEADER));
-        try!(writeln!(w, "{}", RULESETS_HEADER));
-
-        for (name, ruleset) in &self.table.rulesets {
-            try!(writeln!(w, "pub const {}: Ruleset<'static> = Ruleset {{ rules: &[", name.replace("-", "_")));
-            for rule in &ruleset.0 {
-                try!(writeln!(w, "    {:?},", rule));
-            }
-            try!(writeln!(w, "] }};\n\n"));
-        }
-
-        Ok(())
-    }
-
     fn create_structure_directories(&self) -> IoResult<()> {
         let base_mod_path = self.base_path.join("mod.rs");
         let mut base_w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(base_mod_path));
-        try!(write!(base_w, "pub mod rulesets;\n"));
+        try!(writeln!(base_w, "{}", WARNING_HEADER));
+        try!(writeln!(base_w, "{}", ZONEINFO_HEADER));
 
         for entry in self.table.structure() {
             if !entry.name.contains('/') {
@@ -150,38 +133,39 @@ impl DataCrate {
             }
         }
 
+        try!(writeln!(base_w, "\n\n"));
+        for name in self.table.zonesets.keys().filter(|f| !f.contains('/')) {
+            let sanichild = sanitise_name(name);
+            try!(writeln!(base_w, "mod {};", sanichild));
+            try!(writeln!(base_w, "pub use self::{}::ZONE as {};\n", sanichild, sanichild));
+        }
+
+        try!(writeln!(base_w, "\n\n"));
+        try!(writeln!(base_w, "pub fn lookup(input: &str) -> Option<Zone> {{"));
+        for name in self.table.zonesets.keys() {
+            try!(writeln!(base_w, "    if input == {:?} {{", name));
+            try!(writeln!(base_w, "        return Some({});", sanitise_name(name).replace("/", "::")));
+            try!(writeln!(base_w, "    }}"));
+        }
+        try!(writeln!(base_w, "    return None;"));
+        try!(writeln!(base_w, "}}"));
+
         Ok(())
     }
 
     fn write_zonesets(&self) -> IoResult<()> {
-        for (name, zoneset) in &self.table.zonesets {
+        for name in self.table.zonesets.keys() {
             let components: PathBuf = name.split('/').map(sanitise_name).collect();
             let zoneset_path = self.base_path.join(components).with_extension("rs");
             let mut w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(zoneset_path));
             try!(writeln!(w, "{}", WARNING_HEADER));
-            try!(writeln!(w, "{}", ZONESETS_HEADER));
+            try!(writeln!(w, "{}", ZONEINFO_HEADER));
 
             try!(writeln!(w, "pub const ZONE: Zone<'static> = Zone {{"));
             try!(writeln!(w, "    name: {:?},", name));
-            try!(writeln!(w, "    timespans: &["));
-
-            let mut last_end_time: Option<ZoneTime> = None;
-            for info in &zoneset.0 {
-                let saving = match info.saving {
-                    Saving::NoSaving         => "Saving::NoSaving".to_owned(),
-                    Saving::OneOff(by)       => format!("Saving::OneOff({})", by),
-                    Saving::Multiple(ref n)  => format!("Saving::Multiple(&rulesets::{})", sanitise_name(n)),
-                };
-
-                try!(writeln!(w, "        Timespan {{"));
-                try!(writeln!(w, "            offset: {:?},", info.gmt_offset));
-                try!(writeln!(w, "            format: {:?},", info.format));
-                try!(writeln!(w, "            saving: {},", saving));
-                try!(writeln!(w, "            start_time: {:?},", last_end_time.map(|s| s.to_timestamp())));
-                try!(writeln!(w, "            end_time:   {:?},", info.until.map(|s| s.to_timestamp())));
-                try!(writeln!(w, "        }},"));
-
-                last_end_time = info.until;
+            try!(writeln!(w, "    transitions: &["));
+            for info in &self.table.transitions(&*name) {
+                try!(writeln!(w, "        {:?},", info));
             }
             try!(writeln!(w, "    ],"));
             try!(writeln!(w, "}};\n\n"));
@@ -209,18 +193,6 @@ const WARNING_HEADER: &'static str = r##"
 // ------
 "##;
 
-const RULESETS_HEADER: &'static str = r##"
-use code::*;
-use code::YearSpec::*;
-use code::DaySpec::*;
-use datetime::local::Month::*;
-use datetime::local::Weekday::*;
-"##;
-
-const ZONESETS_HEADER: &'static str = r##"
-use code::*;
-use code::Saving::*;
-
-#[allow(unused_imports)]
-use data::rulesets;
+const ZONEINFO_HEADER: &'static str = r##"
+use datetime::zoned::zoneinfo::*;
 "##;
diff --git a/src/lib.rs b/src/lib.rs
index ad72367..9d5ce13 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,7 @@
 //! Parsing Olson DB formats.
 
+#![feature(iter_cmp)]
+
 #![warn(missing_copy_implementations)]
 #![warn(missing_debug_implementations)]
 //#![warn(missing_docs)]
diff --git a/src/line.rs b/src/line.rs
index aac02bf..adce1df 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -2,6 +2,7 @@ use std::ascii::AsciiExt;
 use std::str::FromStr;
 
 use datetime::local::{self, LocalDate, LocalTime, LocalDateTime};
+use datetime::zoned::zoneinfo::TimeType;
 
 use regex::{Regex, Captures};
 
@@ -208,7 +209,7 @@ pub struct ZoneInfo<'line> {
 
     /// The amount of time to be added to Universal TimeSpec, to get standard time
     /// in this zone.
-    pub gmt_offset: TimeSpec,
+    pub utc_offset: TimeSpec,
 
     /// The name of all the rules that should apply in the time zone, or the
     /// amount of time to add.
@@ -240,7 +241,7 @@ impl<'line> Zone<'line> {
 
 impl<'line> ZoneInfo<'line> {
     fn from_captures(caps: Captures<'line>) -> Result<ZoneInfo<'line>, Error> {
-        let gmt_offset    = try!(caps.name("gmtoff").unwrap().parse());
+        let utc_offset    = try!(caps.name("gmtoff").unwrap().parse());
         let saving        = try!(Saving::from_str(caps.name("rulessave").unwrap()));
         let format        = caps.name("format").unwrap();
 
@@ -257,7 +258,7 @@ impl<'line> ZoneInfo<'line> {
         };
 
         Ok(ZoneInfo {
-            gmt_offset:  gmt_offset,
+            utc_offset:  utc_offset,
             saving:      saving,
             format:      format,
             time:        time,
@@ -326,7 +327,6 @@ impl ZoneTime {
     pub fn to_timestamp(&self) -> i64 {
         use self::ZoneTime::*;
         use self::YearSpec::Number;
-        use self::DaySpec::Ordinal;
         use self::TimeSpec::*;
 
         match *self {
@@ -421,7 +421,7 @@ impl FromStr for YearSpec {
 /// A **month** field, which is actually just a wrapper around
 /// `datetime::local::Month`.
 #[derive(PartialEq, Debug, Copy, Clone)]
-pub struct MonthSpec(local::Month);
+pub struct MonthSpec(pub local::Month);
 
 impl FromStr for MonthSpec {
     type Err = Error;
@@ -501,7 +501,7 @@ impl DaySpec {
 
     /// Converts this day specification to a concrete date, given the year and
     /// month it should occur in.
-    fn to_concrete_date(&self, year: i64, month: local::Month) -> LocalDate {
+    pub fn to_concrete_date(&self, year: i64, month: local::Month) -> LocalDate {
         use datetime::local::{LocalDate, Year, DatePiece};
 
         match *self {
@@ -584,26 +584,6 @@ pub enum TimeSpec {
     Zero,
 }
 
-/// The "type" of time that a time is.
-///
-/// A time may be followed with a letter, signifying what 'type'
-/// of time the timestamp is:
-///
-/// - **w** for "wall clock" time (the default),
-/// - **s** for local standard time,jkdx
-/// - **u** or **g** or **z** for universal time.
-#[derive(PartialEq, Debug, Copy, Clone)]
-pub enum TimeType {
-
-    /// Wall-clock time.
-    Wall,
-
-    /// Standard Time.
-    Standard,
-
-    /// Universal Co-ordinated Time.
-    UTC,
-}
 
 /// A time spec *and* a time type. Certain fields need to have both.
 #[derive(PartialEq, Debug, Copy, Clone)]
@@ -641,7 +621,7 @@ impl FromStr for TimeSpecAndType {
         else if let Some(caps) = HM_FIELD.captures(input) {
             let hour   = caps.name("hour").unwrap().parse().unwrap();
             let minute = caps.name("minute").unwrap().parse().unwrap();
-            let flag   = caps.name("flag").and_then(|c| TimeType::from_str(&c[0..1]))
+            let flag   = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
                                           .unwrap_or(TimeType::Wall);
 
             Ok(TimeSpecAndType(TimeSpec::HoursMinutes(hour, minute), flag))
@@ -650,7 +630,7 @@ impl FromStr for TimeSpecAndType {
             let hour   = caps.name("hour").unwrap().parse().unwrap();
             let minute = caps.name("minute").unwrap().parse().unwrap();
             let second = caps.name("second").unwrap().parse().unwrap();
-            let flag   = caps.name("flag").and_then(|c| TimeType::from_str(&c[0..1]))
+            let flag   = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
                                           .unwrap_or(TimeType::Wall);
 
             Ok(TimeSpecAndType(TimeSpec::HoursMinutesSeconds(hour, minute, second), flag))
@@ -673,15 +653,13 @@ impl FromStr for TimeSpec {
     }
 }
 
-impl TimeType {
-    fn from_str(c: &str) -> Option<TimeType> {
-        Some(match c {
-            "w"             => TimeType::Wall,
-            "s"             => TimeType::Standard,
-            "u" | "g" | "z" => TimeType::UTC,
-             _              => return None,
-        })
-    }
+fn parse_time_type(c: &str) -> Option<TimeType> {
+    Some(match c {
+        "w"             => TimeType::Wall,
+        "s"             => TimeType::Standard,
+        "u" | "g" | "z" => TimeType::UTC,
+         _              => return None,
+    })
 }
 
 
@@ -760,6 +738,7 @@ mod test {
 
     mod rules {
         use super::*;
+        use datetime::zoned::zoneinfo::TimeType;
 
         test!(rule_1: "Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D" => Ok(Line::Rule(Rule {
             name:         "US",
@@ -800,11 +779,12 @@ mod test {
 
     mod zones {
         use super::*;
+        use datetime::zoned::zoneinfo::TimeType;
 
         test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Ok(Line::Zone(Zone {
             name: "Australia/Adelaide",
             info: ZoneInfo {
-                gmt_offset:  TimeSpec::HoursMinutes(9, 30),
+                utc_offset:  TimeSpec::HoursMinutes(9, 30),
                 saving:      Saving::Multiple("Aus"),
                 format:      "AC%sT",
                 time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
@@ -812,14 +792,14 @@ mod test {
         })));
 
         test!(continuation_1: "                          9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Ok(Line::Continuation(ZoneInfo {
-            gmt_offset:  TimeSpec::HoursMinutes(9, 30),
+            utc_offset:  TimeSpec::HoursMinutes(9, 30),
             saving:      Saving::Multiple("Aus"),
             format:      "AC%sT",
             time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
         })));
 
         test!(continuation_2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Ok(Line::Continuation(ZoneInfo {
-            gmt_offset:  TimeSpec::HoursMinutes(1, 00),
+            utc_offset:  TimeSpec::HoursMinutes(1, 00),
             saving:      Saving::Multiple("C-Eur"),
             format:      "CE%sT",
             time:        Some(ZoneTime::UntilDay(YearSpec::Number(1943), MonthSpec(local::Month::October), DaySpec::Ordinal(25))),
@@ -828,7 +808,7 @@ mod test {
         test!(zone_hyphen: "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919" => Ok(Line::Zone(Zone {
             name: "Asia/Ust-Nera",
             info: ZoneInfo {
-                gmt_offset:  TimeSpec::HoursMinutesSeconds(9, 32, 54),
+                utc_offset:  TimeSpec::HoursMinutesSeconds(9, 32, 54),
                 saving:      Saving::NoSaving,
                 format:      "LMT",
                 time:        Some(ZoneTime::UntilYear(YearSpec::Number(1919))),
diff --git a/src/table.rs b/src/table.rs
index 52d9f72..9c276a3 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -1,6 +1,8 @@
 use std::collections::hash_map::{HashMap, Entry};
 
-use line::{self, YearSpec, DaySpec, MonthSpec, ZoneTime};
+use line::{self, YearSpec, MonthSpec, DaySpec, ZoneTime};
+use datetime::local::{LocalDateTime, LocalTime};
+use datetime::zoned::zoneinfo::TimeType;
 
 
 /// A table of all the data in one or more zoneinfo files.
@@ -20,8 +22,227 @@ pub struct Table {
 #[derive(PartialEq, Debug, Default)]
 pub struct Ruleset(pub Vec<RuleInfo>);
 
+#[derive(PartialEq, Debug, Clone)]
+pub struct Transition {
+    pub occurs_at:  Option<i64>,
+    pub utc_offset: i64,
+    pub dst_offset: i64,
+    pub name:       String,
+}
+
+impl Transition {
+    pub fn total_offset(&self) -> i64 {
+        self.utc_offset + self.dst_offset
+    }
+}
+
+impl Table {
+    pub fn transitions(&self, zone_name: &str) -> Vec<Transition> {
+        let mut transitions = Vec::new();
+        let mut start_time = None;
+        let mut until_time = None;
+
+        let timespans = &self.zonesets[zone_name];
+        for (i, timespan) in timespans.0.iter().enumerate() {
+            let mut dst_offset = 0;
+            let use_until      = i != timespans.0.len() - 1;
+            let utc_offset     = timespan.offset;
+
+            let mut insert_start_transition = i > 0;
+            let mut start_zone_id = None;
+            let mut start_utc_offset = timespan.offset;
+            let mut start_dst_offset = 0;
+
+            match timespan.saving {
+                Saving::NoSaving => {
+                    dst_offset = 0;
+                    start_zone_id = Some(format_name(&*timespan.format, dst_offset, ""));
+
+                    if insert_start_transition {
+                        let t = Transition {
+                            occurs_at:  Some(start_time.unwrap()),
+                            utc_offset: utc_offset,
+                            dst_offset: dst_offset,
+                            name:       start_zone_id.clone().unwrap_or("".to_string()),
+                        };
+                        transitions.push(t);
+                        insert_start_transition = false;
+                    }
+                    else {
+                        let t = Transition {
+                            occurs_at:  None,
+                            utc_offset: utc_offset,
+                            dst_offset: dst_offset,
+                            name:       start_zone_id.clone().unwrap_or("".to_string()),
+                        };
+                        transitions.push(t);
+                    }
+                },
+
+                Saving::OneOff(amount) => {
+                    dst_offset = amount;
+                    start_zone_id = Some(format_name(&*timespan.format, dst_offset, ""));
+
+                    if insert_start_transition {
+                        let t = Transition {
+                            occurs_at:  Some(start_time.unwrap()),
+                            utc_offset: utc_offset,
+                            dst_offset: dst_offset,
+                            name:       start_zone_id.clone().unwrap_or("".to_string()),
+                        };
+                        transitions.push(t);
+                        insert_start_transition = false;
+                    }
+                    else {
+                        let t = Transition {
+                            occurs_at:  None,
+                            utc_offset: utc_offset,
+                            dst_offset: dst_offset,
+                            name:       start_zone_id.clone().unwrap_or("".to_string()),
+                        };
+                        transitions.push(t);
+                    }
+                },
+
+                Saving::Multiple(ref rules) => {
+                    use datetime::local::DatePiece;
+
+                    for year in 1800..2100 {
+                        if use_until && year > LocalDateTime::at(timespan.end_time.unwrap().to_timestamp()).year() {
+                            break;
+                        }
+
+                        let mut activated_rules = self.rulesets[&*rules].0.iter()
+                                                      .filter(|r| r.applies_to_year(year))
+                                                      .collect::<Vec<_>>();
+
+                        loop {
+                            if use_until {
+                                until_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - dst_offset);
+                            }
+
+                            let pos = {
+                                let earliest = activated_rules.iter().enumerate()
+                                    .min_by(|r| r.1.absolute_datetime(year, utc_offset, dst_offset));
+
+                                match earliest {
+                                    Some((p, _)) => p,
+                                    None         => break,
+                                }
+                            };
+
+                            let earliest_rule = activated_rules.remove(pos);
+                            let earliest_at = earliest_rule.absolute_datetime(year, utc_offset, dst_offset).to_instant().seconds();
+
+                            if use_until && earliest_at >= until_time.unwrap() {
+                                break;
+                            }
+
+                            dst_offset = earliest_rule.time_to_add;
+
+                            if insert_start_transition && earliest_at == start_time.unwrap() {
+                                insert_start_transition = false;
+                            }
+
+                            if insert_start_transition {
+                                if earliest_at < start_time.unwrap() {
+                                    start_utc_offset = timespan.offset;
+                                    start_dst_offset = dst_offset;
+                                    start_zone_id = Some(format_name(&*timespan.format, dst_offset, &*earliest_rule.letters.clone().unwrap_or("".to_string())));
+                                    continue;
+                                }
+
+                                if start_zone_id.is_none() && start_utc_offset + start_dst_offset == timespan.offset + dst_offset {
+                                    start_zone_id = Some(format_name(&*timespan.format, dst_offset, &*earliest_rule.letters.clone().unwrap_or("".to_string())));
+                                }
+                            }
+
+                            let t = Transition {
+                                occurs_at:  Some(earliest_at),
+                                utc_offset: timespan.offset,
+                                dst_offset: earliest_rule.time_to_add,
+                                name:       format_name(&*timespan.format, earliest_rule.time_to_add, &*earliest_rule.letters.clone().unwrap_or("".to_string())),
+                            };
+                            transitions.push(t);
+                        }
+                    }
+                }
+            }
+
+            if insert_start_transition {
+                let t = Transition {
+                    occurs_at:  Some(start_time.unwrap()),
+                    utc_offset: start_utc_offset,
+                    dst_offset: start_dst_offset,
+                    name:       start_zone_id.clone().unwrap_or(timespan.format.clone()),
+                };
+                transitions.push(t);
+            }
+
+            if use_until {
+                start_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - dst_offset);
+            }
+        }
+
+        transitions.sort_by(|a, b| a.occurs_at.cmp(&b.occurs_at));
+
+        let mut from_i = 0;
+        let mut to_i = 0;
+
+        while from_i < transitions.len() {
+            if to_i > 1
+            && transitions[from_i].occurs_at.is_some()
+            && transitions[to_i - 1].occurs_at.is_some()
+            && transitions[from_i].occurs_at.unwrap()   + transitions[to_i - 1].total_offset() <=
+               transitions[to_i - 1].occurs_at.unwrap() + transitions[to_i - 2].total_offset() {
+                transitions[to_i - 1] = Transition {
+                    occurs_at:  transitions[to_i - 1].occurs_at,
+                    name:       transitions[from_i].name.clone(),
+                    utc_offset: transitions[from_i].utc_offset,
+                    dst_offset: transitions[from_i].dst_offset,
+                };
+
+                from_i += 1;
+                continue;
+            }
+
+            if to_i == 0
+            || transitions[to_i - 1].utc_offset != transitions[from_i].utc_offset
+            || transitions[to_i - 1].dst_offset != transitions[from_i].dst_offset {
+                transitions[to_i] = transitions[from_i].clone();
+                to_i += 1;
+            }
+
+            from_i += 1
+        }
+
+        if to_i > 0 {
+            transitions.truncate(to_i);
+        }
+
+        transitions
+    }
+}
+
+fn format_name(template: &str, dst_offset: i64, letters: &str) -> String {
+    if let Some(pos) = template.find('/') {
+        if dst_offset == 0 {
+            template[.. pos].to_owned()
+        }
+        else {
+            template[pos + 1 ..].to_owned()
+        }
+    }
+    else if template.contains("%s") {
+        template.replace("%s", letters)
+    }
+    else {
+        template.to_owned()
+    }
+}
+
 #[derive(PartialEq, Debug)]
-struct RuleInfo {
+pub struct RuleInfo {
 
     /// The year that this rule *starts* applying.
     from_year: YearSpec,
@@ -39,6 +260,9 @@ struct RuleInfo {
     /// The exact time it applies on.
     time: i64,
 
+    /// The type of time that time is.
+    time_type: TimeType,
+
     /// The amount of time to save.
     time_to_add: i64,
 
@@ -55,21 +279,49 @@ impl<'_> From<line::Rule<'_>> for RuleInfo {
             month:        info.month,
             day:          info.day,
             time:         info.time.0.as_seconds(),
+            time_type:    info.time.1,
             time_to_add:  info.time_to_add.as_seconds(),
             letters:      info.letters.map(str::to_owned),
         }
     }
 }
 
+impl RuleInfo {
+    fn applies_to_year(&self, year: i64) -> bool {
+        use line::YearSpec::*;
+
+        match (self.from_year, self.to_year) {
+            (Number(from), None)             => year == from,
+            (Number(from), Some(Maximum))    => year >= from,
+            (Number(from), Some(Number(to))) => year >= from && year <= to,
+            _ => unreachable!(),
+        }
+    }
+
+    fn absolute_datetime(&self, year: i64, utc_offset: i64, dst_offset: i64) -> LocalDateTime {
+        use datetime::duration::Duration;
+
+        let offset = match self.time_type {
+            TimeType::UTC       => 0,
+            TimeType::Standard  => utc_offset,
+            TimeType::Wall      => utc_offset + dst_offset,
+        };
+
+        let date = self.day.to_concrete_date(year, self.month.0);
+        let time = LocalTime::from_seconds_since_midnight(self.time);
+        LocalDateTime::new(date, time) - Duration::of(offset)
+    }
+}
+
 #[derive(PartialEq, Debug, Default)]
 pub struct Zoneset(pub Vec<ZoneInfo>);
 
 #[derive(PartialEq, Debug)]
 pub struct ZoneInfo {
-    pub gmt_offset: i64,
-    pub format:     String,
-    pub saving:     Saving,
-    pub until:      Option<ZoneTime>,
+    pub offset:    i64,
+    pub format:    String,
+    pub saving:    Saving,
+    pub end_time:  Option<ZoneTime>,
 }
 
 #[derive(PartialEq, Debug)]
@@ -82,14 +334,14 @@ pub enum Saving {
 impl<'_> From<line::ZoneInfo<'_>> for ZoneInfo {
     fn from(info: line::ZoneInfo) -> ZoneInfo {
         ZoneInfo {
-            gmt_offset: info.gmt_offset.as_seconds(),
+            offset: info.utc_offset.as_seconds(),
             saving: match info.saving {
                 line::Saving::NoSaving     => Saving::NoSaving,
                 line::Saving::Multiple(s)  => Saving::Multiple(s.to_owned()),
                 line::Saving::OneOff(t)    => Saving::OneOff(t.as_seconds()),
             },
             format: info.format.to_owned(),
-            until: info.time,
+            end_time: info.time,
         }
     }
 }
@@ -185,6 +437,7 @@ impl TableBuilder {
     }
 }
 
+
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub enum Error<'line> {
 
@@ -200,4 +453,281 @@ pub enum Error<'line> {
 
     /// A zone line was passed in, but there's already a zone with that name.
     DuplicateZone,
-}
\ No newline at end of file
+}
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use super::transitions;
+    use local::Weekday::*;
+    use local::Month::*;
+    use super::DaySpec::*;
+    use super::YearSpec::*;
+    use super::TimeType::*;
+
+    #[test]
+    fn no_transitions() {
+        let timespan = Timespan {
+            offset: 1234,
+            format: "TEST",
+            saving: Saving::NoSaving,
+            end_time: None,
+        };
+
+        let zone = Zone {
+            name: "Test/Zone",
+            timespans: &[ timespan ],
+        };
+
+        assert_eq!(zone.transitions(), vec![
+            Transition {
+                occurs_at: None,
+                utc_offset: 1234,
+                dst_offset: 0,
+            }
+        ]);
+    }
+
+    #[test]
+    fn one_transition() {
+        let timespan_1 = Timespan {
+            offset: 1234,
+            format: "TEST",
+            saving: Saving::NoSaving,
+            end_time: Some(123456),
+        };
+
+        let timespan_2 = Timespan {
+            offset: 5678,
+            format: "TSET",
+            saving: Saving::NoSaving,
+            end_time: None,
+        };
+
+        let zone = Zone {
+            name: "Test/Zone",
+            timespans: &[ timespan_1, timespan_2 ],
+        };
+
+        assert_eq!(zone.transitions(), vec![
+            Transition {
+                occurs_at: None,
+                utc_offset: 1234,
+                dst_offset: 0,
+            },
+            Transition {
+                occurs_at: Some(122222),
+                utc_offset: 5678,
+                dst_offset: 0,
+            },
+        ]);
+    }
+
+
+    #[test]
+    fn two_transitions() {
+        let timespan_1 = Timespan {
+            offset: 1234,
+            format: "TEST",
+            saving: Saving::NoSaving,
+            end_time: Some(123456),
+        };
+
+        let timespan_2 = Timespan {
+            offset: 3456,
+            format: "TSET",
+            saving: Saving::NoSaving,
+            end_time: Some(234567),
+        };
+
+        let timespan_3 = Timespan {
+            offset: 5678,
+            format: "ESTE",
+            saving: Saving::NoSaving,
+            end_time: None,
+        };
+
+        let zone = Zone {
+            name: "Test/Zone",
+            timespans: &[ timespan_1, timespan_2, timespan_3 ],
+        };
+
+        assert_eq!(zone.transitions(), vec![
+            Transition {
+                occurs_at: None,
+                utc_offset: 1234,
+                dst_offset: 0,
+            },
+            Transition {
+                occurs_at: Some(122222),
+                utc_offset: 3456,
+                dst_offset: 0,
+            },
+            Transition {
+                occurs_at: Some(231111),
+                utc_offset: 5678,
+                dst_offset: 0,
+            },
+        ]);
+    }
+
+    #[test]
+    fn one_rule() {
+        let ruleset = Ruleset { rules: &[
+            RuleInfo {
+                from_year:   Number(1980),
+                to_year:     None,
+                month:       MonthSpec(February),
+                day:         Ordinal(4),
+                time:        0,
+                time_type:   UTC,
+                time_to_add: 1000,
+                letters:     None,
+            }
+        ] };
+
+        let timespan = Timespan {
+            offset: 2000,
+            format: "TEST",
+            saving: Saving::Multiple(&ruleset),
+            end_time: None,
+        };
+
+        let zone = Zone {
+            name: "Test/Zone",
+            timespans: &[ timespan ],
+        };
+
+        assert_eq!(zone.transitions(), vec![
+            Transition {
+                occurs_at:  Some(318_470_400),
+                utc_offset: 2000,
+                dst_offset: 1000,
+            },
+        ]);
+    }
+
+    #[test]
+    fn two_rules() {
+        let ruleset = Ruleset { rules: &[
+            RuleInfo {
+                from_year:   Number(1980),
+                to_year:     None,
+                month:       MonthSpec(February),
+                day:         Ordinal(4),
+                time:        0,
+                time_type:   UTC,
+                time_to_add: 1000,
+                letters:     None,
+            },
+            RuleInfo {
+                from_year:   Number(1989),
+                to_year:     None,
+                month:       MonthSpec(January),
+                day:         Ordinal(12),
+                time:        0,
+                time_type:   UTC,
+                time_to_add: 1500,
+                letters:     None,
+            },
+        ] };
+
+        let timespan = Timespan {
+            offset: 2000,
+            format: "TEST",
+            saving: Saving::Multiple(&ruleset),
+            end_time: None,
+        };
+
+        let zone = Zone {
+            name: "Test/Zone",
+            timespans: &[ timespan ],
+        };
+
+        assert_eq!(zone.transitions(), vec![
+            Transition {
+                occurs_at:  Some(318_470_400),
+                utc_offset: 2000,
+                dst_offset: 1000,
+            },
+            Transition {
+                occurs_at:  Some(600_566_400),
+                utc_offset: 2000,
+                dst_offset: 1500,
+            },
+        ]);
+    }
+
+    #[test]
+    fn tripoli() {
+        let libya = Ruleset { rules: &[
+            RuleInfo { from_year: Number(1951), to_year: None,               month: MonthSpec(October),   day: Ordinal(14),               time: 7200, time_type: Wall, time_to_add: 3600, letters: Some("S") },
+            RuleInfo { from_year: Number(1952), to_year: None,               month: MonthSpec(January),   day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
+            RuleInfo { from_year: Number(1953), to_year: None,               month: MonthSpec(October),   day: Ordinal(9),                time: 7200, time_type: Wall, time_to_add: 3600, letters: Some("S") },
+            RuleInfo { from_year: Number(1954), to_year: None,               month: MonthSpec(January),   day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
+            RuleInfo { from_year: Number(1955), to_year: None,               month: MonthSpec(September), day: Ordinal(30),               time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
+            RuleInfo { from_year: Number(1956), to_year: None,               month: MonthSpec(January),   day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
+            RuleInfo { from_year: Number(1982), to_year: Some(Number(1984)), month: MonthSpec(April),     day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
+            RuleInfo { from_year: Number(1982), to_year: Some(Number(1985)), month: MonthSpec(October),   day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
+            RuleInfo { from_year: Number(1985), to_year: None,               month: MonthSpec(April),     day: Ordinal(6),                time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
+            RuleInfo { from_year: Number(1986), to_year: None,               month: MonthSpec(April),     day: Ordinal(4),                time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
+            RuleInfo { from_year: Number(1986), to_year: None,               month: MonthSpec(October),   day: Ordinal(3),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
+            RuleInfo { from_year: Number(1987), to_year: Some(Number(1989)), month: MonthSpec(April),     day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
+            RuleInfo { from_year: Number(1987), to_year: Some(Number(1989)), month: MonthSpec(October),   day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
+            RuleInfo { from_year: Number(1997), to_year: None,               month: MonthSpec(April),     day: Ordinal(4),                time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
+            RuleInfo { from_year: Number(1997), to_year: None,               month: MonthSpec(October),   day: Ordinal(4),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
+            RuleInfo { from_year: Number(2013), to_year: None,               month: MonthSpec(March),     day: Last(WeekdaySpec(Friday)), time: 3600, time_type: Wall, time_to_add: 3600, letters: Some("S") },
+            RuleInfo { from_year: Number(2013), to_year: None,               month: MonthSpec(October),   day: Last(WeekdaySpec(Friday)), time: 7200, time_type: Wall, time_to_add: 0,    letters: None      },
+        ] };
+
+        let timespans = &[
+            Timespan { offset: 3164, format: "LMT",   saving: Saving::NoSaving,         end_time: Some(-1577923200),},
+            Timespan { offset: 3600, format: "CE%sT", saving: Saving::Multiple(&libya), end_time: Some(-347155200),},
+            Timespan { offset: 7200, format: "EET",   saving: Saving::NoSaving,         end_time: Some(378691200),},
+            Timespan { offset: 3600, format: "CE%sT", saving: Saving::Multiple(&libya), end_time: Some(641779200),},
+            Timespan { offset: 7200, format: "EET",   saving: Saving::NoSaving,         end_time: Some(844041600),},
+            Timespan { offset: 3600, format: "CE%sT", saving: Saving::Multiple(&libya), end_time: Some(875923200),},
+            Timespan { offset: 7200, format: "EET",   saving: Saving::NoSaving,         end_time: Some(1352512800),},
+            Timespan { offset: 3600, format: "CE%sT", saving: Saving::Multiple(&libya), end_time: Some(1382666400),},
+            Timespan { offset: 7200, format: "EET",   saving: Saving::NoSaving,         end_time: None,},
+        ];
+
+        let transitions = transitions(timespans);
+        assert_eq!(transitions, vec![
+            Transition { utc_offset: 3164, dst_offset: 0,    occurs_at: None                 },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(-1_577_926_364) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -574_902_000) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -568_087_200) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -512_175_600) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -504_928_800) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -449_888_400) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -441_856_800) },
+            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(  -347_158_800) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   378_684_000) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   386_463_600) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   402_271_200) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   417_999_600) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   433_807_200) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   449_622_000) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   465_429_600) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   481_590_000) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   496_965_600) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   512_953_200) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   528_674_400) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   544_230_000) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   560_037_600) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   575_852_400) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   591_660_000) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   607_388_400) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   623_196_000) },
+            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(   641_775_600) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   844_034_400) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   860_108_400) },
+            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(   875_916_000) },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some( 1_352_505_600) },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some( 1_364_515_200) },
+            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some( 1_382_659_200) },
+        ]);
+    }
+}

From 0228da89806f7df34c7bf10e3ed3f8a663555e48 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Tue, 27 Oct 2015 21:43:54 +0000
Subject: [PATCH 012/113] Move optimisation to its own function

---
 src/table.rs | 75 +++++++++++++++++++++++++++-------------------------
 1 file changed, 39 insertions(+), 36 deletions(-)

diff --git a/src/table.rs b/src/table.rs
index 9c276a3..c838e86 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -184,42 +184,7 @@ impl Table {
             }
         }
 
-        transitions.sort_by(|a, b| a.occurs_at.cmp(&b.occurs_at));
-
-        let mut from_i = 0;
-        let mut to_i = 0;
-
-        while from_i < transitions.len() {
-            if to_i > 1
-            && transitions[from_i].occurs_at.is_some()
-            && transitions[to_i - 1].occurs_at.is_some()
-            && transitions[from_i].occurs_at.unwrap()   + transitions[to_i - 1].total_offset() <=
-               transitions[to_i - 1].occurs_at.unwrap() + transitions[to_i - 2].total_offset() {
-                transitions[to_i - 1] = Transition {
-                    occurs_at:  transitions[to_i - 1].occurs_at,
-                    name:       transitions[from_i].name.clone(),
-                    utc_offset: transitions[from_i].utc_offset,
-                    dst_offset: transitions[from_i].dst_offset,
-                };
-
-                from_i += 1;
-                continue;
-            }
-
-            if to_i == 0
-            || transitions[to_i - 1].utc_offset != transitions[from_i].utc_offset
-            || transitions[to_i - 1].dst_offset != transitions[from_i].dst_offset {
-                transitions[to_i] = transitions[from_i].clone();
-                to_i += 1;
-            }
-
-            from_i += 1
-        }
-
-        if to_i > 0 {
-            transitions.truncate(to_i);
-        }
-
+        sort_and_optimise(&mut transitions);
         transitions
     }
 }
@@ -241,6 +206,44 @@ fn format_name(template: &str, dst_offset: i64, letters: &str) -> String {
     }
 }
 
+fn sort_and_optimise(transitions: &mut Vec<Transition>) {
+    transitions.sort_by(|a, b| a.occurs_at.cmp(&b.occurs_at));
+
+    let mut from_i = 0;
+    let mut to_i = 0;
+
+    while from_i < transitions.len() {
+        if to_i > 1
+        && transitions[from_i].occurs_at.is_some()
+        && transitions[to_i - 1].occurs_at.is_some()
+        && transitions[from_i].occurs_at.unwrap()   + transitions[to_i - 1].total_offset() <=
+           transitions[to_i - 1].occurs_at.unwrap() + transitions[to_i - 2].total_offset() {
+            transitions[to_i - 1] = Transition {
+                occurs_at:  transitions[to_i - 1].occurs_at,
+                name:       transitions[from_i].name.clone(),
+                utc_offset: transitions[from_i].utc_offset,
+                dst_offset: transitions[from_i].dst_offset,
+            };
+
+            from_i += 1;
+            continue;
+        }
+
+        if to_i == 0
+        || transitions[to_i - 1].utc_offset != transitions[from_i].utc_offset
+        || transitions[to_i - 1].dst_offset != transitions[from_i].dst_offset {
+            transitions[to_i] = transitions[from_i].clone();
+            to_i += 1;
+        }
+
+        from_i += 1
+    }
+
+    if to_i > 0 {
+        transitions.truncate(to_i);
+    }
+}
+
 #[derive(PartialEq, Debug)]
 pub struct RuleInfo {
 

From e93c720195137557f18ef265d953444a3331cc03 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Wed, 28 Oct 2015 10:14:36 +0000
Subject: [PATCH 013/113] Parse formatting strings beforehand

This introduces a Format enum, which parses the formats beforehand, and figures out which to use based on that. It still panicks, though.
---
 src/table.rs | 80 ++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 55 insertions(+), 25 deletions(-)

diff --git a/src/table.rs b/src/table.rs
index c838e86..7dc7e88 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -56,7 +56,7 @@ impl Table {
             match timespan.saving {
                 Saving::NoSaving => {
                     dst_offset = 0;
-                    start_zone_id = Some(format_name(&*timespan.format, dst_offset, ""));
+                    start_zone_id = Some(timespan.format.format_constant());
 
                     if insert_start_transition {
                         let t = Transition {
@@ -81,7 +81,7 @@ impl Table {
 
                 Saving::OneOff(amount) => {
                     dst_offset = amount;
-                    start_zone_id = Some(format_name(&*timespan.format, dst_offset, ""));
+                    start_zone_id = Some(timespan.format.format_constant());
 
                     if insert_start_transition {
                         let t = Transition {
@@ -148,12 +148,12 @@ impl Table {
                                 if earliest_at < start_time.unwrap() {
                                     start_utc_offset = timespan.offset;
                                     start_dst_offset = dst_offset;
-                                    start_zone_id = Some(format_name(&*timespan.format, dst_offset, &*earliest_rule.letters.clone().unwrap_or("".to_string())));
+                                    start_zone_id = Some(timespan.format.format(dst_offset, earliest_rule.letters.as_ref()));
                                     continue;
                                 }
 
                                 if start_zone_id.is_none() && start_utc_offset + start_dst_offset == timespan.offset + dst_offset {
-                                    start_zone_id = Some(format_name(&*timespan.format, dst_offset, &*earliest_rule.letters.clone().unwrap_or("".to_string())));
+                                    start_zone_id = Some(timespan.format.format(dst_offset, earliest_rule.letters.as_ref()));
                                 }
                             }
 
@@ -161,7 +161,7 @@ impl Table {
                                 occurs_at:  Some(earliest_at),
                                 utc_offset: timespan.offset,
                                 dst_offset: earliest_rule.time_to_add,
-                                name:       format_name(&*timespan.format, earliest_rule.time_to_add, &*earliest_rule.letters.clone().unwrap_or("".to_string())),
+                                name:       timespan.format.format(earliest_rule.time_to_add, earliest_rule.letters.as_ref()),
                             };
                             transitions.push(t);
                         }
@@ -174,7 +174,7 @@ impl Table {
                     occurs_at:  Some(start_time.unwrap()),
                     utc_offset: start_utc_offset,
                     dst_offset: start_dst_offset,
-                    name:       start_zone_id.clone().unwrap_or(timespan.format.clone()),
+                    name:       start_zone_id.clone().unwrap(),
                 };
                 transitions.push(t);
             }
@@ -189,23 +189,6 @@ impl Table {
     }
 }
 
-fn format_name(template: &str, dst_offset: i64, letters: &str) -> String {
-    if let Some(pos) = template.find('/') {
-        if dst_offset == 0 {
-            template[.. pos].to_owned()
-        }
-        else {
-            template[pos + 1 ..].to_owned()
-        }
-    }
-    else if template.contains("%s") {
-        template.replace("%s", letters)
-    }
-    else {
-        template.to_owned()
-    }
-}
-
 fn sort_and_optimise(transitions: &mut Vec<Transition>) {
     transitions.sort_by(|a, b| a.occurs_at.cmp(&b.occurs_at));
 
@@ -322,7 +305,7 @@ pub struct Zoneset(pub Vec<ZoneInfo>);
 #[derive(PartialEq, Debug)]
 pub struct ZoneInfo {
     pub offset:    i64,
-    pub format:    String,
+    pub format:    Format,
     pub saving:    Saving,
     pub end_time:  Option<ZoneTime>,
 }
@@ -334,6 +317,13 @@ pub enum Saving {
     Multiple(String),
 }
 
+#[derive(PartialEq, Debug, Clone)]
+pub enum Format {
+    Constant(String),
+    Alternate { standard: String, dst: String },
+    Placeholder(String),
+}
+
 impl<'_> From<line::ZoneInfo<'_>> for ZoneInfo {
     fn from(info: line::ZoneInfo) -> ZoneInfo {
         ZoneInfo {
@@ -343,12 +333,52 @@ impl<'_> From<line::ZoneInfo<'_>> for ZoneInfo {
                 line::Saving::Multiple(s)  => Saving::Multiple(s.to_owned()),
                 line::Saving::OneOff(t)    => Saving::OneOff(t.as_seconds()),
             },
-            format: info.format.to_owned(),
+            format:   Format::new(info.format),
             end_time: info.time,
         }
     }
 }
 
+impl Format {
+    fn new(template: &str) -> Format {
+        if let Some(pos) = template.find('/') {
+            Format::Alternate {
+                standard:  template[.. pos].to_owned(),
+                dst:       template[pos + 1 ..].to_owned(),
+            }
+        }
+        else if template.contains("%s") {
+            Format::Placeholder(template.to_owned())
+        }
+        else {
+            Format::Constant(template.to_owned())
+        }
+    }
+
+    fn format(&self, dst_offset: i64, letters: Option<&String>) -> String {
+        let letters = match letters {
+            Some(l) => &**l,
+            None    => "",
+        };
+
+        match *self {
+            Format::Constant(ref s) => s.clone(),
+            Format::Placeholder(ref s) => s.replace("%s", letters),
+            Format::Alternate { ref standard, .. } if dst_offset == 0 => standard.clone(),
+            Format::Alternate { ref dst, .. } => dst.clone(),
+        }
+    }
+
+    fn format_constant(&self) -> String {
+        if let Format::Constant(ref s) = *self {
+            s.clone()
+        }
+        else {
+            panic!("Expected a constant formatting string");
+        }
+    }
+}
+
 
 /// A builder for `Table` values based on various line definitions.
 #[derive(PartialEq, Debug)]

From 7d4a8be676da48eb29335c82c6b250df22b628f6 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Wed, 28 Oct 2015 10:20:15 +0000
Subject: [PATCH 014/113] Sort timezones alphabetically in the main module

This makes it easier to test whether things have changed between crate compilations.
---
 bin/build-data-crate.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 9760be9..cfe78dc 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -133,8 +133,11 @@ impl DataCrate {
             }
         }
 
+        let mut keys: Vec<_> = self.table.zonesets.keys().collect();
+        keys.sort();
+
         try!(writeln!(base_w, "\n\n"));
-        for name in self.table.zonesets.keys().filter(|f| !f.contains('/')) {
+        for name in keys.iter().filter(|f| !f.contains('/')) {
             let sanichild = sanitise_name(name);
             try!(writeln!(base_w, "mod {};", sanichild));
             try!(writeln!(base_w, "pub use self::{}::ZONE as {};\n", sanichild, sanichild));
@@ -142,7 +145,7 @@ impl DataCrate {
 
         try!(writeln!(base_w, "\n\n"));
         try!(writeln!(base_w, "pub fn lookup(input: &str) -> Option<Zone> {{"));
-        for name in self.table.zonesets.keys() {
+        for name in &keys {
             try!(writeln!(base_w, "    if input == {:?} {{", name));
             try!(writeln!(base_w, "        return Some({});", sanitise_name(name).replace("/", "::")));
             try!(writeln!(base_w, "    }}"));

From db97b5747a635e7abe9deb197ef4c4f883ed7ac2 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Wed, 28 Oct 2015 17:19:50 +0000
Subject: [PATCH 015/113] Fix tests

Add a test for the transition-optimisation function, which uses some of the Antarctica/Macquarie rules. However, fix all the other tests to get it to compile at all!

- I had to replace some of the end times (123456 and 234567) with their ZoneTime equivalent.
- This required some of the fields for the spec structs in line.rs to be made public.
---
 src/line.rs  |   4 +-
 src/table.rs | 308 ++++++++++++++++++++++++++++-----------------------
 2 files changed, 173 insertions(+), 139 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index adce1df..524d647 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -450,7 +450,7 @@ impl FromStr for MonthSpec {
 /// A **weekday** field, which is actually just a wrapper around
 /// `datetime::local::Weekday`.
 #[derive(PartialEq, Debug, Copy, Clone)]
-pub struct WeekdaySpec(local::Weekday);
+pub struct WeekdaySpec(pub local::Weekday);
 
 impl FromStr for WeekdaySpec {
     type Err = Error;
@@ -592,7 +592,7 @@ pub struct TimeSpecAndType(pub TimeSpec, pub TimeType);
 impl TimeSpec {
 
     #[cfg(test)]
-    fn with_type(self, time_type: TimeType) -> TimeSpecAndType {
+    pub fn with_type(self, time_type: TimeType) -> TimeSpecAndType {
         TimeSpecAndType(self, time_type)
     }
 
diff --git a/src/table.rs b/src/table.rs
index 7dc7e88..7d3c7f7 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -184,14 +184,13 @@ impl Table {
             }
         }
 
-        sort_and_optimise(&mut transitions);
+        transitions.sort_by(|a, b| a.occurs_at.cmp(&b.occurs_at));
+        optimise(&mut transitions);
         transitions
     }
 }
 
-fn sort_and_optimise(transitions: &mut Vec<Transition>) {
-    transitions.sort_by(|a, b| a.occurs_at.cmp(&b.occurs_at));
-
+fn optimise(transitions: &mut Vec<Transition>) {
     let mut from_i = 0;
     let mut to_i = 0;
 
@@ -214,7 +213,8 @@ fn sort_and_optimise(transitions: &mut Vec<Transition>) {
 
         if to_i == 0
         || transitions[to_i - 1].utc_offset != transitions[from_i].utc_offset
-        || transitions[to_i - 1].dst_offset != transitions[from_i].dst_offset {
+        || transitions[to_i - 1].dst_offset != transitions[from_i].dst_offset
+        || transitions[to_i - 1].name       != transitions[from_i].name {
             transitions[to_i] = transitions[from_i].clone();
             to_i += 1;
         }
@@ -491,68 +491,70 @@ pub enum Error<'line> {
 
 #[cfg(test)]
 mod test {
-    use super::*;
-    use super::transitions;
-    use local::Weekday::*;
-    use local::Month::*;
-    use super::DaySpec::*;
-    use super::YearSpec::*;
-    use super::TimeType::*;
+    use super::{Transition, Saving, ZoneInfo, RuleInfo, Ruleset, Table, Zoneset, Format, optimise};
+    use datetime::local::Weekday::*;
+    use datetime::local::Month::*;
+    use datetime::zoned::zoneinfo::TimeType;
+    use line::DaySpec;
+    use line::WeekdaySpec;
+    use line::MonthSpec;
+    use line::YearSpec;
+    use line::TimeSpec;
+    use line::ZoneTime;
 
     #[test]
     fn no_transitions() {
-        let timespan = Timespan {
+        let zone = ZoneInfo {
             offset: 1234,
-            format: "TEST",
+            format: Format::new("TEST"),
             saving: Saving::NoSaving,
             end_time: None,
         };
 
-        let zone = Zone {
-            name: "Test/Zone",
-            timespans: &[ timespan ],
-        };
+        let mut table = Table::default();
+        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone ]));
 
-        assert_eq!(zone.transitions(), vec![
+        assert_eq!(table.transitions("Test/Zone"), vec![
             Transition {
-                occurs_at: None,
+                occurs_at:  None,
                 utc_offset: 1234,
                 dst_offset: 0,
+                name:       "TEST".to_owned(),
             }
         ]);
     }
 
     #[test]
     fn one_transition() {
-        let timespan_1 = Timespan {
+        let zone_1 = ZoneInfo {
             offset: 1234,
-            format: "TEST",
+            format: Format::new("TEST"),
             saving: Saving::NoSaving,
-            end_time: Some(123456),
+            end_time: Some(ZoneTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(2), TimeSpec::HoursMinutesSeconds(10, 17, 36).with_type(TimeType::UTC))),
         };
 
-        let timespan_2 = Timespan {
+        let zone_2 = ZoneInfo {
             offset: 5678,
-            format: "TSET",
+            format: Format::new("TSET"),
             saving: Saving::NoSaving,
             end_time: None,
         };
 
-        let zone = Zone {
-            name: "Test/Zone",
-            timespans: &[ timespan_1, timespan_2 ],
-        };
+        let mut table = Table::default();
+        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone_1, zone_2 ]));
 
-        assert_eq!(zone.transitions(), vec![
+        assert_eq!(table.transitions("Test/Zone"), vec![
             Transition {
                 occurs_at: None,
                 utc_offset: 1234,
                 dst_offset: 0,
+                name:       "TEST".to_owned(),
             },
             Transition {
                 occurs_at: Some(122222),
                 utc_offset: 5678,
                 dst_offset: 0,
+                name:       "TSET".to_owned(),
             },
         ]);
     }
@@ -560,207 +562,239 @@ mod test {
 
     #[test]
     fn two_transitions() {
-        let timespan_1 = Timespan {
+        let zone_1 = ZoneInfo {
             offset: 1234,
-            format: "TEST",
+            format: Format::new("TEST"),
             saving: Saving::NoSaving,
-            end_time: Some(123456),
+            end_time: Some(ZoneTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(2), TimeSpec::HoursMinutesSeconds(10, 17, 36).with_type(TimeType::Standard))),
         };
 
-        let timespan_2 = Timespan {
+        let zone_2 = ZoneInfo {
             offset: 3456,
-            format: "TSET",
+            format: Format::new("TSET"),
             saving: Saving::NoSaving,
-            end_time: Some(234567),
+            end_time: Some(ZoneTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(3), TimeSpec::HoursMinutesSeconds(17, 09, 27).with_type(TimeType::Standard))),
         };
 
-        let timespan_3 = Timespan {
+        let zone_3 = ZoneInfo {
             offset: 5678,
-            format: "ESTE",
+            format: Format::new("ESTE"),
             saving: Saving::NoSaving,
             end_time: None,
         };
 
-        let zone = Zone {
-            name: "Test/Zone",
-            timespans: &[ timespan_1, timespan_2, timespan_3 ],
-        };
+        let mut table = Table::default();
+        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone_1, zone_2, zone_3 ]));
 
-        assert_eq!(zone.transitions(), vec![
+        assert_eq!(table.transitions("Test/Zone"), vec![
             Transition {
                 occurs_at: None,
                 utc_offset: 1234,
                 dst_offset: 0,
+                name: "TEST".to_owned(),
             },
             Transition {
                 occurs_at: Some(122222),
                 utc_offset: 3456,
                 dst_offset: 0,
+                name: "TSET".to_owned(),
             },
             Transition {
                 occurs_at: Some(231111),
                 utc_offset: 5678,
                 dst_offset: 0,
+                name: "ESTE".to_owned(),
             },
         ]);
     }
 
     #[test]
     fn one_rule() {
-        let ruleset = Ruleset { rules: &[
+        let ruleset = Ruleset(vec![
             RuleInfo {
-                from_year:   Number(1980),
+                from_year:   YearSpec::Number(1980),
                 to_year:     None,
                 month:       MonthSpec(February),
-                day:         Ordinal(4),
+                day:         DaySpec::Ordinal(4),
                 time:        0,
-                time_type:   UTC,
+                time_type:   TimeType::UTC,
                 time_to_add: 1000,
                 letters:     None,
             }
-        ] };
+        ]);
 
-        let timespan = Timespan {
+        let zone = ZoneInfo {
             offset: 2000,
-            format: "TEST",
-            saving: Saving::Multiple(&ruleset),
+            format: Format::new("TEST"),
+            saving: Saving::Multiple("Dwayne".to_owned()),
             end_time: None,
         };
 
-        let zone = Zone {
-            name: "Test/Zone",
-            timespans: &[ timespan ],
-        };
+        let mut table = Table::default();
+        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone ]));
+        table.rulesets.insert("Dwayne".to_owned(), ruleset);
 
-        assert_eq!(zone.transitions(), vec![
+        assert_eq!(table.transitions("Test/Zone"), vec![
             Transition {
                 occurs_at:  Some(318_470_400),
                 utc_offset: 2000,
                 dst_offset: 1000,
+                name:       "TEST".to_owned(),
             },
         ]);
     }
 
     #[test]
     fn two_rules() {
-        let ruleset = Ruleset { rules: &[
+        let ruleset = Ruleset(vec![
             RuleInfo {
-                from_year:   Number(1980),
+                from_year:   YearSpec::Number(1980),
                 to_year:     None,
                 month:       MonthSpec(February),
-                day:         Ordinal(4),
+                day:         DaySpec::Ordinal(4),
                 time:        0,
-                time_type:   UTC,
+                time_type:   TimeType::UTC,
                 time_to_add: 1000,
                 letters:     None,
             },
             RuleInfo {
-                from_year:   Number(1989),
+                from_year:   YearSpec::Number(1989),
                 to_year:     None,
                 month:       MonthSpec(January),
-                day:         Ordinal(12),
+                day:         DaySpec::Ordinal(12),
                 time:        0,
-                time_type:   UTC,
+                time_type:   TimeType::UTC,
                 time_to_add: 1500,
                 letters:     None,
             },
-        ] };
+        ]);
 
-        let timespan = Timespan {
+        let zone = ZoneInfo {
             offset: 2000,
-            format: "TEST",
-            saving: Saving::Multiple(&ruleset),
+            format: Format::new("TEST"),
+            saving: Saving::Multiple("Dwayne".to_owned()),
             end_time: None,
         };
 
-        let zone = Zone {
-            name: "Test/Zone",
-            timespans: &[ timespan ],
-        };
+        let mut table = Table::default();
+        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone ]));
+        table.rulesets.insert("Dwayne".to_owned(), ruleset);
 
-        assert_eq!(zone.transitions(), vec![
+        assert_eq!(table.transitions("Test/Zone"), vec![
             Transition {
                 occurs_at:  Some(318_470_400),
                 utc_offset: 2000,
                 dst_offset: 1000,
+                name:       "TEST".to_owned(),
             },
             Transition {
                 occurs_at:  Some(600_566_400),
                 utc_offset: 2000,
                 dst_offset: 1500,
+                name:       "TEST".to_owned(),
             },
         ]);
     }
 
     #[test]
     fn tripoli() {
-        let libya = Ruleset { rules: &[
-            RuleInfo { from_year: Number(1951), to_year: None,               month: MonthSpec(October),   day: Ordinal(14),               time: 7200, time_type: Wall, time_to_add: 3600, letters: Some("S") },
-            RuleInfo { from_year: Number(1952), to_year: None,               month: MonthSpec(January),   day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
-            RuleInfo { from_year: Number(1953), to_year: None,               month: MonthSpec(October),   day: Ordinal(9),                time: 7200, time_type: Wall, time_to_add: 3600, letters: Some("S") },
-            RuleInfo { from_year: Number(1954), to_year: None,               month: MonthSpec(January),   day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
-            RuleInfo { from_year: Number(1955), to_year: None,               month: MonthSpec(September), day: Ordinal(30),               time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
-            RuleInfo { from_year: Number(1956), to_year: None,               month: MonthSpec(January),   day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
-            RuleInfo { from_year: Number(1982), to_year: Some(Number(1984)), month: MonthSpec(April),     day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
-            RuleInfo { from_year: Number(1982), to_year: Some(Number(1985)), month: MonthSpec(October),   day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
-            RuleInfo { from_year: Number(1985), to_year: None,               month: MonthSpec(April),     day: Ordinal(6),                time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
-            RuleInfo { from_year: Number(1986), to_year: None,               month: MonthSpec(April),     day: Ordinal(4),                time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
-            RuleInfo { from_year: Number(1986), to_year: None,               month: MonthSpec(October),   day: Ordinal(3),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
-            RuleInfo { from_year: Number(1987), to_year: Some(Number(1989)), month: MonthSpec(April),     day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
-            RuleInfo { from_year: Number(1987), to_year: Some(Number(1989)), month: MonthSpec(October),   day: Ordinal(1),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
-            RuleInfo { from_year: Number(1997), to_year: None,               month: MonthSpec(April),     day: Ordinal(4),                time: 0,    time_type: Wall, time_to_add: 3600, letters: Some("S") },
-            RuleInfo { from_year: Number(1997), to_year: None,               month: MonthSpec(October),   day: Ordinal(4),                time: 0,    time_type: Wall, time_to_add: 0,    letters: None      },
-            RuleInfo { from_year: Number(2013), to_year: None,               month: MonthSpec(March),     day: Last(WeekdaySpec(Friday)), time: 3600, time_type: Wall, time_to_add: 3600, letters: Some("S") },
-            RuleInfo { from_year: Number(2013), to_year: None,               month: MonthSpec(October),   day: Last(WeekdaySpec(Friday)), time: 7200, time_type: Wall, time_to_add: 0,    letters: None      },
-        ] };
-
-        let timespans = &[
-            Timespan { offset: 3164, format: "LMT",   saving: Saving::NoSaving,         end_time: Some(-1577923200),},
-            Timespan { offset: 3600, format: "CE%sT", saving: Saving::Multiple(&libya), end_time: Some(-347155200),},
-            Timespan { offset: 7200, format: "EET",   saving: Saving::NoSaving,         end_time: Some(378691200),},
-            Timespan { offset: 3600, format: "CE%sT", saving: Saving::Multiple(&libya), end_time: Some(641779200),},
-            Timespan { offset: 7200, format: "EET",   saving: Saving::NoSaving,         end_time: Some(844041600),},
-            Timespan { offset: 3600, format: "CE%sT", saving: Saving::Multiple(&libya), end_time: Some(875923200),},
-            Timespan { offset: 7200, format: "EET",   saving: Saving::NoSaving,         end_time: Some(1352512800),},
-            Timespan { offset: 3600, format: "CE%sT", saving: Saving::Multiple(&libya), end_time: Some(1382666400),},
-            Timespan { offset: 7200, format: "EET",   saving: Saving::NoSaving,         end_time: None,},
+        let libya = Ruleset(vec![
+            RuleInfo { from_year: YearSpec::Number(1951), to_year: None,               month: MonthSpec(October),   day: DaySpec::Ordinal(14),               time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1952), to_year: None,               month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1953), to_year: None,               month: MonthSpec(October),   day: DaySpec::Ordinal(9),                time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1954), to_year: None,               month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1955), to_year: None,               month: MonthSpec(September), day: DaySpec::Ordinal(30),               time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1956), to_year: None,               month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1982), to_year: Some(YearSpec::Number(1984)), month: MonthSpec(April),     day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1982), to_year: Some(YearSpec::Number(1985)), month: MonthSpec(October),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1985), to_year: None,               month: MonthSpec(April),     day: DaySpec::Ordinal(6),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1986), to_year: None,               month: MonthSpec(April),     day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1986), to_year: None,               month: MonthSpec(October),   day: DaySpec::Ordinal(3),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1987), to_year: Some(YearSpec::Number(1989)), month: MonthSpec(April),     day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1987), to_year: Some(YearSpec::Number(1989)), month: MonthSpec(October),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1997), to_year: None,               month: MonthSpec(April),     day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1997), to_year: None,               month: MonthSpec(October),   day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(2013), to_year: None,               month: MonthSpec(March),     day: DaySpec::Last(WeekdaySpec(Friday)), time: 3600, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(2013), to_year: None,               month: MonthSpec(October),   day: DaySpec::Last(WeekdaySpec(Friday)), time: 7200, time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+        ]);
+
+        let zone = vec![
+            ZoneInfo { offset: 3164, format: Format::new("LMT"),   saving: Saving::NoSaving,                     end_time: Some(ZoneTime::UntilYear(YearSpec::Number(1920))) },
+            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ZoneTime::UntilYear(YearSpec::Number(1959)))  },
+            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ZoneTime::UntilYear(YearSpec::Number(1982)))   },
+            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ZoneTime::UntilDay (YearSpec::Number(1990), MonthSpec(May),       DaySpec::Ordinal( 4)))   },
+            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ZoneTime::UntilDay (YearSpec::Number(1996), MonthSpec(September), DaySpec::Ordinal(30)))   },
+            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ZoneTime::UntilDay (YearSpec::Number(1997), MonthSpec(October),   DaySpec::Ordinal( 4)))   },
+            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ZoneTime::UntilTime(YearSpec::Number(2012), MonthSpec(November),  DaySpec::Ordinal(10), TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall)))  },
+            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ZoneTime::UntilTime(YearSpec::Number(2013), MonthSpec(October),   DaySpec::Ordinal(25), TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall)))  },
+            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: None              },
         ];
 
-        let transitions = transitions(timespans);
-        assert_eq!(transitions, vec![
-            Transition { utc_offset: 3164, dst_offset: 0,    occurs_at: None                 },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(-1_577_926_364) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -574_902_000) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -568_087_200) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -512_175_600) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -504_928_800) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -449_888_400) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -441_856_800) },
-            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(  -347_158_800) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   378_684_000) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   386_463_600) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   402_271_200) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   417_999_600) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   433_807_200) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   449_622_000) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   465_429_600) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   481_590_000) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   496_965_600) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   512_953_200) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   528_674_400) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   544_230_000) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   560_037_600) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   575_852_400) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   591_660_000) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   607_388_400) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   623_196_000) },
-            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(   641_775_600) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   844_034_400) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   860_108_400) },
-            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(   875_916_000) },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some( 1_352_505_600) },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some( 1_364_515_200) },
-            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some( 1_382_659_200) },
+        let mut table = Table::default();
+        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(zone));
+        table.rulesets.insert("Libya".to_owned(), libya);
+
+        assert_eq!(table.transitions("Test/Zone"), vec![
+            Transition { utc_offset: 3164, dst_offset: 0,    occurs_at: None,                 name:  "LMT".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(-1_577_926_364), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -574_902_000), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -568_087_200), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -512_175_600), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -504_928_800), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -449_888_400), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -441_856_800), name:  "CET".to_owned() },
+            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(  -347_158_800), name:  "EET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   378_684_000), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   386_463_600), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   402_271_200), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   417_999_600), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   433_807_200), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   449_622_000), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   465_429_600), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   481_590_000), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   496_965_600), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   512_953_200), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   528_674_400), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   544_230_000), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   560_037_600), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   575_852_400), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   591_660_000), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   607_388_400), name: "CEST".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   623_196_000), name:  "CET".to_owned() },
+            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(   641_775_600), name:  "EET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   844_034_400), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   860_108_400), name: "CEST".to_owned() },
+            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(   875_916_000), name:  "EET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some( 1_352_505_600), name:  "CET".to_owned() },
+            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some( 1_364_515_200), name: "CEST".to_owned() },
+            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some( 1_382_659_200), name:  "EET".to_owned() },
         ]);
     }
+
+    #[test]
+    fn optimise_macquarie() {
+        let mut transitions = vec![
+            Transition { occurs_at: None,              utc_offset:     0, dst_offset:    0, name:  "zzz".to_owned() },
+            Transition { occurs_at: Some(-2214259200), utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },
+            Transition { occurs_at: Some(-1680508800), utc_offset: 36000, dst_offset: 3600, name: "AEDT".to_owned() },
+            Transition { occurs_at: Some(-1669892400), utc_offset: 36000, dst_offset: 3600, name: "AEDT".to_owned() },  // gets removed
+            Transition { occurs_at: Some(-1665392400), utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },
+            Transition { occurs_at: Some(-1601719200), utc_offset:     0, dst_offset:    0, name:  "zzz".to_owned() },
+            Transition { occurs_at: Some(-687052800),  utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },
+            Transition { occurs_at: Some(-94730400),   utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },  // also gets removed
+            Transition { occurs_at: Some(-71136000),   utc_offset: 36000, dst_offset: 3600, name: "AEDT".to_owned() },
+            Transition { occurs_at: Some(-55411200),   utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },
+            Transition { occurs_at: Some(-37267200),   utc_offset: 36000, dst_offset: 3600, name: "AEDT".to_owned() },
+            Transition { occurs_at: Some(-25776000),   utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },
+            Transition { occurs_at: Some(-5817600),    utc_offset: 36000, dst_offset: 3600, name: "AEDT".to_owned() },
+        ];
+
+        let mut result = transitions.clone();
+        result.remove(7);
+        result.remove(3);
+
+        optimise(&mut transitions);
+        assert_eq!(transitions, result);
+    }
+
 }

From a1b868eaa61404151b9e6a894e6dd7f5d25ab2cc Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 29 Oct 2015 11:30:04 +0000
Subject: [PATCH 016/113] Remove unwraps in optimise

This makes the code more Rustful, and has no changes to the resulting output.
---
 src/table.rs | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/table.rs b/src/table.rs
index 7d3c7f7..b298e68 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -195,20 +195,22 @@ fn optimise(transitions: &mut Vec<Transition>) {
     let mut to_i = 0;
 
     while from_i < transitions.len() {
-        if to_i > 1
-        && transitions[from_i].occurs_at.is_some()
-        && transitions[to_i - 1].occurs_at.is_some()
-        && transitions[from_i].occurs_at.unwrap()   + transitions[to_i - 1].total_offset() <=
-           transitions[to_i - 1].occurs_at.unwrap() + transitions[to_i - 2].total_offset() {
-            transitions[to_i - 1] = Transition {
-                occurs_at:  transitions[to_i - 1].occurs_at,
-                name:       transitions[from_i].name.clone(),
-                utc_offset: transitions[from_i].utc_offset,
-                dst_offset: transitions[from_i].dst_offset,
-            };
-
-            from_i += 1;
-            continue;
+        if to_i > 1 {
+            if let (Some(from), Some(to)) = (transitions[from_i].occurs_at, transitions[to_i - 1].occurs_at) {
+                if from + transitions[to_i - 1].total_offset() <= to + transitions[to_i - 2].total_offset() {
+                    let replacement_transition = Transition {
+                        occurs_at:  transitions[to_i - 1].occurs_at,
+                        name:       transitions[from_i].name.clone(),
+                        utc_offset: transitions[from_i].utc_offset,
+                        dst_offset: transitions[from_i].dst_offset,
+                    };
+
+                    transitions[to_i - 1] = replacement_transition;
+                    from_i += 1;
+                    continue;
+                }
+            }
+
         }
 
         if to_i == 0

From 30fa66cd11e1fafcd9d983e2ed955f461abc7b2a Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 29 Oct 2015 11:32:57 +0000
Subject: [PATCH 017/113] Disable unused_results lint in tests code

This makes it compile without warnings again!
---
 src/table.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/table.rs b/src/table.rs
index b298e68..7bc6be9 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -493,6 +493,13 @@ pub enum Error<'line> {
 
 #[cfg(test)]
 mod test {
+
+    // Allow unused results in test code, because the only 'results' that
+    // we need to ignore are the ones from inserting and removing from
+    // tables and vectors. And as we set them up ourselves, they're bound
+    // to be correct, otherwise the tests would fail!
+    #![allow(unused_results)]
+
     use super::{Transition, Saving, ZoneInfo, RuleInfo, Ruleset, Table, Zoneset, Format, optimise};
     use datetime::local::Weekday::*;
     use datetime::local::Month::*;

From 6d602a2bd7cd2193160d412d2631cf10786c78ea Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 29 Oct 2015 11:36:06 +0000
Subject: [PATCH 018/113] Remove linker error workaround

The error in question appears to have gone away! Current version:

rustc 1.5.0-nightly (95fb8d1c8 2015-10-27)
---
 src/lib.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 9d5ce13..eb8be08 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -14,8 +14,7 @@ extern crate regex;
 #[macro_use] extern crate lazy_static;
 
 mod line;
-pub use line::{Line, ZoneTime};
-// ^ ZoneTime needs to be here, otherwise you get a linker error (weird!)
+pub use line::Line;
 
 mod table;
 pub use table::{Table, TableBuilder, Saving};

From 2679f0d0127f3bdc4afe659bb7bb96dac2a281fa Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 29 Oct 2015 12:20:33 +0000
Subject: [PATCH 019/113] Use the development version of datetime for now

---
 Cargo.toml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 91ddd77..a24f0a4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,6 +8,8 @@ name = "build-data-crate"
 path = "bin/build-data-crate.rs"
 
 [dependencies]
-datetime = "*"
 lazy_static = "*"
 regex = "*"
+
+[dependencies.datetime]
+git = "https://github.com/rust-datetime/datetime.git"
\ No newline at end of file

From 757b16f6d79d4ab6b60460a496216da026a7f201 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 30 Oct 2015 12:55:36 +0000
Subject: [PATCH 020/113] Store only the total offset in a transition

Commit 2551f9224a1c188cc7f963f504b27c8cea4d92ae to datetime changes the Transition struct to only have one offset field, rather than two. This commit changes the data crate builder to use the new version of the struct.

Also, work around a linker error that I'm not even sure why I'm getting.
---
 bin/build-data-crate.rs | 10 +++++++---
 src/lib.rs              |  3 ++-
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index cfe78dc..706a8cb 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -9,10 +9,10 @@ use std::fs::{File, OpenOptions, create_dir, metadata};
 use std::path::{Path, PathBuf};
 use std::process::exit;
 
+
 fn main() {
     let args: Vec<_> = args().skip(1).collect();
 
-    // let base_path = "~/Code/datetime/zoneinfo-data/src/data";
     let data_crate = match DataCrate::new(&args[0], &args[1..]) {
         Ok(dc) => dc,
         Err(_) => {
@@ -167,8 +167,12 @@ impl DataCrate {
             try!(writeln!(w, "pub const ZONE: Zone<'static> = Zone {{"));
             try!(writeln!(w, "    name: {:?},", name));
             try!(writeln!(w, "    transitions: &["));
-            for info in &self.table.transitions(&*name) {
-                try!(writeln!(w, "        {:?},", info));
+            for t in &self.table.transitions(&*name) {
+                try!(writeln!(w, "        Transition {{"));
+                try!(writeln!(w, "            occurs_at: {:?},", t.occurs_at));
+                try!(writeln!(w, "            offset: {:?},",     t.total_offset()));
+                try!(writeln!(w, "            name: {:?},",      t.name));
+                try!(writeln!(w, "        }},"));
             }
             try!(writeln!(w, "    ],"));
             try!(writeln!(w, "}};\n\n"));
diff --git a/src/lib.rs b/src/lib.rs
index eb8be08..7eee8ab 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -17,7 +17,8 @@ mod line;
 pub use line::Line;
 
 mod table;
-pub use table::{Table, TableBuilder, Saving};
+pub use table::{Table, TableBuilder, Saving, Transition};
+// ^ Transition needs to be there, otherwise you get a linker error. Weird huh?
 
 mod structure;
 pub use structure::*;
\ No newline at end of file

From 609f69c0cdd972baded1670c0cb1f62b8b499ee2 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 30 Oct 2015 13:00:55 +0000
Subject: [PATCH 021/113] Write the operation to the data crate, too

This makes it easier to see how the consolidated offset was produced.
---
 bin/build-data-crate.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 706a8cb..c51ef91 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -170,8 +170,12 @@ impl DataCrate {
             for t in &self.table.transitions(&*name) {
                 try!(writeln!(w, "        Transition {{"));
                 try!(writeln!(w, "            occurs_at: {:?},", t.occurs_at));
-                try!(writeln!(w, "            offset: {:?},",     t.total_offset()));
-                try!(writeln!(w, "            name: {:?},",      t.name));
+
+                // Write the total offset (the only value that gets used)
+                // and both the offsets that get added together, as a
+                // comment in the data crate.
+                try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", t.total_offset(), t.utc_offset, t.dst_offset));
+                try!(writeln!(w, "            name: {:?},", t.name));
                 try!(writeln!(w, "        }},"));
             }
             try!(writeln!(w, "    ],"));

From 74f69f6b834b5a40f9f9ffbdf9a8293a45301587 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 5 Nov 2015 01:59:03 +0000
Subject: [PATCH 022/113] Replace optional transition times with fixed time
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This marks a change to the way transition data was calculated and stored.

Previously, each timespan—a period of consistent time zone name, GMT offset, and DST offset—was stored as a transition with an optional timestamp at which the transition occurs. This doesn’t solve the problem of what the time details should be *before* the first transition has occurred, which is why the timestamp was optional: the first period would simply have a `None` timestamp.

This approach had problems, namely:

1. It was possible to have multiple `None` timestamps, which would confuse the datetime calculator;
2. It was not only possible but actually manifest to have time zones with *zero* `None` timestamps, which would also confuse the datetime calculator.

To remove the possibility of having invalid data, each time zone now has one fixed “ante” period, and at least zero transitions, each of which now has a non-Optional timestamp.

It’s a rather simple change, but most of the terminology has been updated to reflect this—Transition to ZoneDetails, among other structs—which is where most of the lines in the diff come from.

The only time zones that change in zoneinfo-data are the “fixed” ones like CET or EST5EDT.
---
 bin/build-data-crate.rs |  17 +++++--
 src/lib.rs              |   3 +-
 src/table.rs            | 103 +++++++++++++++++++++-------------------
 3 files changed, 69 insertions(+), 54 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index c51ef91..0f37478 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -167,15 +167,24 @@ impl DataCrate {
             try!(writeln!(w, "pub const ZONE: Zone<'static> = Zone {{"));
             try!(writeln!(w, "    name: {:?},", name));
             try!(writeln!(w, "    transitions: &["));
-            for t in &self.table.transitions(&*name) {
+
+            let set = self.table.transitions(&*name);
+
+                try!(writeln!(w, "        Transition {{"));
+                try!(writeln!(w, "            occurs_at: None,"));
+                try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", set.first.total_offset(), set.first.utc_offset, set.first.dst_offset));
+                try!(writeln!(w, "            name: {:?},", set.first.name));
+                try!(writeln!(w, "        }},"));
+
+            for t in &set.rest {
                 try!(writeln!(w, "        Transition {{"));
-                try!(writeln!(w, "            occurs_at: {:?},", t.occurs_at));
+                try!(writeln!(w, "            occurs_at: {:?},", Some(t.0)));
 
                 // Write the total offset (the only value that gets used)
                 // and both the offsets that get added together, as a
                 // comment in the data crate.
-                try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", t.total_offset(), t.utc_offset, t.dst_offset));
-                try!(writeln!(w, "            name: {:?},", t.name));
+                try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", t.1.total_offset(), t.1.utc_offset, t.1.dst_offset));
+                try!(writeln!(w, "            name: {:?},", t.1.name));
                 try!(writeln!(w, "        }},"));
             }
             try!(writeln!(w, "    ],"));
diff --git a/src/lib.rs b/src/lib.rs
index 7eee8ab..44ddffe 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -17,8 +17,7 @@ mod line;
 pub use line::Line;
 
 mod table;
-pub use table::{Table, TableBuilder, Saving, Transition};
-// ^ Transition needs to be there, otherwise you get a linker error. Weird huh?
+pub use table::{Table, TableBuilder, Saving, ZoneSet, ZoneDetails};
 
 mod structure;
 pub use structure::*;
\ No newline at end of file
diff --git a/src/table.rs b/src/table.rs
index 7bc6be9..07701b2 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -23,25 +23,32 @@ pub struct Table {
 pub struct Ruleset(pub Vec<RuleInfo>);
 
 #[derive(PartialEq, Debug, Clone)]
-pub struct Transition {
-    pub occurs_at:  Option<i64>,
+pub struct ZoneSet {
+    pub first: ZoneDetails,
+    pub rest: Vec<(i64, ZoneDetails)>,
+}
+
+#[derive(PartialEq, Debug, Clone)]
+pub struct ZoneDetails {
     pub utc_offset: i64,
     pub dst_offset: i64,
     pub name:       String,
 }
 
-impl Transition {
+impl ZoneDetails {
     pub fn total_offset(&self) -> i64 {
         self.utc_offset + self.dst_offset
     }
 }
 
 impl Table {
-    pub fn transitions(&self, zone_name: &str) -> Vec<Transition> {
+    pub fn transitions(&self, zone_name: &str) -> ZoneSet {
         let mut transitions = Vec::new();
         let mut start_time = None;
         let mut until_time = None;
 
+        let mut first_transition = None;
+
         let timespans = &self.zonesets[zone_name];
         for (i, timespan) in timespans.0.iter().enumerate() {
             let mut dst_offset = 0;
@@ -59,23 +66,20 @@ impl Table {
                     start_zone_id = Some(timespan.format.format_constant());
 
                     if insert_start_transition {
-                        let t = Transition {
-                            occurs_at:  Some(start_time.unwrap()),
+                        let t = (start_time.unwrap(), ZoneDetails {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
                             name:       start_zone_id.clone().unwrap_or("".to_string()),
-                        };
+                        });
                         transitions.push(t);
                         insert_start_transition = false;
                     }
                     else {
-                        let t = Transition {
-                            occurs_at:  None,
+                        first_transition = Some(ZoneDetails {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
                             name:       start_zone_id.clone().unwrap_or("".to_string()),
-                        };
-                        transitions.push(t);
+                        });
                     }
                 },
 
@@ -84,23 +88,20 @@ impl Table {
                     start_zone_id = Some(timespan.format.format_constant());
 
                     if insert_start_transition {
-                        let t = Transition {
-                            occurs_at:  Some(start_time.unwrap()),
+                        let t = (start_time.unwrap(), ZoneDetails {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
                             name:       start_zone_id.clone().unwrap_or("".to_string()),
-                        };
+                        });
                         transitions.push(t);
                         insert_start_transition = false;
                     }
                     else {
-                        let t = Transition {
-                            occurs_at:  None,
+                        first_transition = Some(ZoneDetails {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
                             name:       start_zone_id.clone().unwrap_or("".to_string()),
-                        };
-                        transitions.push(t);
+                        });
                     }
                 },
 
@@ -157,12 +158,11 @@ impl Table {
                                 }
                             }
 
-                            let t = Transition {
-                                occurs_at:  Some(earliest_at),
+                            let t = (earliest_at, ZoneDetails {
                                 utc_offset: timespan.offset,
                                 dst_offset: earliest_rule.time_to_add,
                                 name:       timespan.format.format(earliest_rule.time_to_add, earliest_rule.letters.as_ref()),
-                            };
+                            });
                             transitions.push(t);
                         }
                     }
@@ -170,12 +170,11 @@ impl Table {
             }
 
             if insert_start_transition {
-                let t = Transition {
-                    occurs_at:  Some(start_time.unwrap()),
+                let t = (start_time.unwrap(), ZoneDetails {
                     utc_offset: start_utc_offset,
                     dst_offset: start_dst_offset,
                     name:       start_zone_id.clone().unwrap(),
-                };
+                });
                 transitions.push(t);
             }
 
@@ -184,40 +183,44 @@ impl Table {
             }
         }
 
-        transitions.sort_by(|a, b| a.occurs_at.cmp(&b.occurs_at));
-        optimise(&mut transitions);
-        transitions
+        transitions.sort_by(|a, b| a.0.cmp(&b.0));
+
+        let first = match first_transition {
+            Some(ft) => ft,
+            None     => transitions.iter().find(|t| t.1.dst_offset == 0).unwrap().1.clone(),
+        };
+
+        let mut zoneset = ZoneSet {
+            first: first,
+            rest:  transitions,
+        };
+        optimise(&mut zoneset);
+        zoneset
     }
 }
 
-fn optimise(transitions: &mut Vec<Transition>) {
+fn optimise(transitions: &mut ZoneSet) {
     let mut from_i = 0;
     let mut to_i = 0;
 
-    while from_i < transitions.len() {
+    while from_i < transitions.rest.len() {
         if to_i > 1 {
-            if let (Some(from), Some(to)) = (transitions[from_i].occurs_at, transitions[to_i - 1].occurs_at) {
-                if from + transitions[to_i - 1].total_offset() <= to + transitions[to_i - 2].total_offset() {
-                    let replacement_transition = Transition {
-                        occurs_at:  transitions[to_i - 1].occurs_at,
-                        name:       transitions[from_i].name.clone(),
-                        utc_offset: transitions[from_i].utc_offset,
-                        dst_offset: transitions[from_i].dst_offset,
-                    };
-
-                    transitions[to_i - 1] = replacement_transition;
-                    from_i += 1;
-                    continue;
-                }
+            let from = transitions.rest[from_i].0;
+            let to = transitions.rest[to_i - 1].0;
+            if from + transitions.rest[to_i - 1].1.total_offset() <= to + transitions.rest[to_i - 2].1.total_offset() {
+                let replacement_transition = (transitions.rest[to_i - 1].0, transitions.rest[from_i].1.clone());
+
+                transitions.rest[to_i - 1] = replacement_transition;
+                from_i += 1;
+                continue;
             }
-
         }
 
         if to_i == 0
-        || transitions[to_i - 1].utc_offset != transitions[from_i].utc_offset
-        || transitions[to_i - 1].dst_offset != transitions[from_i].dst_offset
-        || transitions[to_i - 1].name       != transitions[from_i].name {
-            transitions[to_i] = transitions[from_i].clone();
+        || transitions.rest[to_i - 1].1.utc_offset != transitions.rest[from_i].1.utc_offset
+        || transitions.rest[to_i - 1].1.dst_offset != transitions.rest[from_i].1.dst_offset
+        || transitions.rest[to_i - 1].1.name       != transitions.rest[from_i].1.name {
+            transitions.rest[to_i] = transitions.rest[from_i].clone();
             to_i += 1;
         }
 
@@ -225,7 +228,11 @@ fn optimise(transitions: &mut Vec<Transition>) {
     }
 
     if to_i > 0 {
-        transitions.truncate(to_i);
+        transitions.rest.truncate(to_i);
+    }
+
+    if !transitions.rest.is_empty() && transitions.first == transitions.rest[0].1 {
+        transitions.rest.remove(0);
     }
 }
 

From dff66d45d54247c295c12281927d40ea6644ea13 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 5 Nov 2015 12:04:28 +0000
Subject: [PATCH 023/113] Optimise optimisation routine

This uses the PartialEq implementation on ZoneDetails to simplify some of the code, which was getting rather repetitive.
---
 src/table.rs | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/src/table.rs b/src/table.rs
index 07701b2..7c8ddfa 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -199,6 +199,7 @@ impl Table {
     }
 }
 
+#[allow(unused_results)]  // for remove
 fn optimise(transitions: &mut ZoneSet) {
     let mut from_i = 0;
     let mut to_i = 0;
@@ -208,18 +209,13 @@ fn optimise(transitions: &mut ZoneSet) {
             let from = transitions.rest[from_i].0;
             let to = transitions.rest[to_i - 1].0;
             if from + transitions.rest[to_i - 1].1.total_offset() <= to + transitions.rest[to_i - 2].1.total_offset() {
-                let replacement_transition = (transitions.rest[to_i - 1].0, transitions.rest[from_i].1.clone());
-
-                transitions.rest[to_i - 1] = replacement_transition;
+                transitions.rest[to_i - 1].1 = transitions.rest[from_i].1.clone();
                 from_i += 1;
                 continue;
             }
         }
 
-        if to_i == 0
-        || transitions.rest[to_i - 1].1.utc_offset != transitions.rest[from_i].1.utc_offset
-        || transitions.rest[to_i - 1].1.dst_offset != transitions.rest[from_i].1.dst_offset
-        || transitions.rest[to_i - 1].1.name       != transitions.rest[from_i].1.name {
+        if to_i == 0 || transitions.rest[to_i - 1].1 != transitions.rest[from_i].1 {
             transitions.rest[to_i] = transitions.rest[from_i].clone();
             to_i += 1;
         }
@@ -227,9 +223,7 @@ fn optimise(transitions: &mut ZoneSet) {
         from_i += 1
     }
 
-    if to_i > 0 {
-        transitions.rest.truncate(to_i);
-    }
+    transitions.rest.truncate(to_i);
 
     if !transitions.rest.is_empty() && transitions.first == transitions.rest[0].1 {
         transitions.rest.remove(0);

From 1167868975417e90a5f18e1fa4b241074756d7cf Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 5 Nov 2015 12:10:08 +0000
Subject: [PATCH 024/113] Adapt the data crate builder to use ZoneSet

build-data-crate.rs now uses the new ZoneSet instead of Transition, which is great because Transition doesn't exist anymore.

See 74f69f6b834b5a40f9f9ffbdf9a8293a45301587 for more information on why this is necessary.
---
 Cargo.toml              |  4 +---
 bin/build-data-crate.rs | 20 ++++++++++----------
 2 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index a24f0a4..91ddd77 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,8 +8,6 @@ name = "build-data-crate"
 path = "bin/build-data-crate.rs"
 
 [dependencies]
+datetime = "*"
 lazy_static = "*"
 regex = "*"
-
-[dependencies.datetime]
-git = "https://github.com/rust-datetime/datetime.git"
\ No newline at end of file
diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 0f37478..ca16727 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -166,28 +166,28 @@ impl DataCrate {
 
             try!(writeln!(w, "pub const ZONE: Zone<'static> = Zone {{"));
             try!(writeln!(w, "    name: {:?},", name));
-            try!(writeln!(w, "    transitions: &["));
+            try!(writeln!(w, "    transitions: ZoneSet {{"));
 
             let set = self.table.transitions(&*name);
 
-                try!(writeln!(w, "        Transition {{"));
-                try!(writeln!(w, "            occurs_at: None,"));
-                try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", set.first.total_offset(), set.first.utc_offset, set.first.dst_offset));
-                try!(writeln!(w, "            name: {:?},", set.first.name));
-                try!(writeln!(w, "        }},"));
+            try!(writeln!(w, "        first: ZoneDetails {{"));
+            try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", set.first.total_offset(), set.first.utc_offset, set.first.dst_offset));
+            try!(writeln!(w, "            name: {:?},", set.first.name));
+            try!(writeln!(w, "        }},"));
+
+            try!(writeln!(w, "        rest: &["));
 
             for t in &set.rest {
-                try!(writeln!(w, "        Transition {{"));
-                try!(writeln!(w, "            occurs_at: {:?},", Some(t.0)));
+                try!(writeln!(w, "        ({:?}, ZoneDetails {{", t.0));
 
                 // Write the total offset (the only value that gets used)
                 // and both the offsets that get added together, as a
                 // comment in the data crate.
                 try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", t.1.total_offset(), t.1.utc_offset, t.1.dst_offset));
                 try!(writeln!(w, "            name: {:?},", t.1.name));
-                try!(writeln!(w, "        }},"));
+                try!(writeln!(w, "        }}),"));
             }
-            try!(writeln!(w, "    ],"));
+            try!(writeln!(w, "    ]}},"));
             try!(writeln!(w, "}};\n\n"));
         }
 

From 47b056f6b0526b03e2f151b1f8c5890b051baf85 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Wed, 11 Nov 2015 11:55:13 +0000
Subject: [PATCH 025/113] Naming updates from datetime

ZoneDetails to FixedTimespan, and ZoneSet to FixedTimespanSet. Also, add the transition instant time for clarity.
---
 bin/build-data-crate.rs | 27 ++++++++++++++++-----------
 src/line.rs             |  2 +-
 src/table.rs            |  2 +-
 3 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index ca16727..11b0a45 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -1,6 +1,3 @@
-extern crate zoneinfo_parse;
-use zoneinfo_parse::{Line, TableBuilder, Table, Structure, Child};
-
 use std::env::args;
 use std::io::prelude::*;
 use std::io::BufReader;
@@ -9,6 +6,12 @@ use std::fs::{File, OpenOptions, create_dir, metadata};
 use std::path::{Path, PathBuf};
 use std::process::exit;
 
+extern crate datetime;
+use datetime::local::LocalDateTime;
+
+extern crate zoneinfo_parse;
+use zoneinfo_parse::{Line, TableBuilder, Table, Structure, Child};
+
 
 fn main() {
     let args: Vec<_> = args().skip(1).collect();
@@ -144,7 +147,7 @@ impl DataCrate {
         }
 
         try!(writeln!(base_w, "\n\n"));
-        try!(writeln!(base_w, "pub fn lookup(input: &str) -> Option<Zone> {{"));
+        try!(writeln!(base_w, "pub fn lookup(input: &str) -> Option<TimeZone> {{"));
         for name in &keys {
             try!(writeln!(base_w, "    if input == {:?} {{", name));
             try!(writeln!(base_w, "        return Some({});", sanitise_name(name).replace("/", "::")));
@@ -164,27 +167,29 @@ impl DataCrate {
             try!(writeln!(w, "{}", WARNING_HEADER));
             try!(writeln!(w, "{}", ZONEINFO_HEADER));
 
-            try!(writeln!(w, "pub const ZONE: Zone<'static> = Zone {{"));
+            try!(writeln!(w, "pub const ZONE: TimeZone<'static> = TimeZone {{"));
             try!(writeln!(w, "    name: {:?},", name));
-            try!(writeln!(w, "    transitions: ZoneSet {{"));
+            try!(writeln!(w, "    fixed_timespans: FixedTimespanSet {{"));
 
             let set = self.table.transitions(&*name);
 
-            try!(writeln!(w, "        first: ZoneDetails {{"));
+            try!(writeln!(w, "        first: FixedTimespan {{"));
             try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", set.first.total_offset(), set.first.utc_offset, set.first.dst_offset));
-            try!(writeln!(w, "            name: {:?},", set.first.name));
+            try!(writeln!(w, "            is_dst: {:?},", set.first.dst_offset != 0));
+            try!(writeln!(w, "            name:   {:?},", set.first.name));
             try!(writeln!(w, "        }},"));
 
             try!(writeln!(w, "        rest: &["));
 
             for t in &set.rest {
-                try!(writeln!(w, "        ({:?}, ZoneDetails {{", t.0));
+                try!(writeln!(w, "        ({:?}, FixedTimespan {{  // {:?} UTC", t.0, LocalDateTime::at(t.0)));
 
                 // Write the total offset (the only value that gets used)
                 // and both the offsets that get added together, as a
                 // comment in the data crate.
                 try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", t.1.total_offset(), t.1.utc_offset, t.1.dst_offset));
-                try!(writeln!(w, "            name: {:?},", t.1.name));
+                try!(writeln!(w, "            is_dst: {:?},", t.1.dst_offset != 0));
+                try!(writeln!(w, "            name:   {:?},", t.1.name));
                 try!(writeln!(w, "        }}),"));
             }
             try!(writeln!(w, "    ]}},"));
@@ -214,5 +219,5 @@ const WARNING_HEADER: &'static str = r##"
 "##;
 
 const ZONEINFO_HEADER: &'static str = r##"
-use datetime::zoned::zoneinfo::*;
+use datetime::zoned::zoned::*;
 "##;
diff --git a/src/line.rs b/src/line.rs
index 524d647..f8f28fd 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -2,7 +2,7 @@ use std::ascii::AsciiExt;
 use std::str::FromStr;
 
 use datetime::local::{self, LocalDate, LocalTime, LocalDateTime};
-use datetime::zoned::zoneinfo::TimeType;
+use datetime::zoned::TimeType;
 
 use regex::{Regex, Captures};
 
diff --git a/src/table.rs b/src/table.rs
index 7c8ddfa..3f41f26 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -2,7 +2,7 @@ use std::collections::hash_map::{HashMap, Entry};
 
 use line::{self, YearSpec, MonthSpec, DaySpec, ZoneTime};
 use datetime::local::{LocalDateTime, LocalTime};
-use datetime::zoned::zoneinfo::TimeType;
+use datetime::zoned::TimeType;
 
 
 /// A table of all the data in one or more zoneinfo files.

From b3f5a91ee9d0e8ed926536327677dfab3b62faa1 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Wed, 11 Nov 2015 17:30:36 +0000
Subject: [PATCH 026/113] Module updates from datetime

Many types have been moved to the root of the crate, with others (such as TimeType) accessible from a different module now.

See datetime@b86a5752678d2cf410b37c909309138895a61f8a for the commit that necessitated. this.
---
 bin/build-data-crate.rs | 10 ++++--
 src/line.rs             | 75 +++++++++++++++++++++--------------------
 src/table.rs            | 14 ++++----
 3 files changed, 52 insertions(+), 47 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 11b0a45..89b488e 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -7,7 +7,7 @@ use std::path::{Path, PathBuf};
 use std::process::exit;
 
 extern crate datetime;
-use datetime::local::LocalDateTime;
+use datetime::LocalDateTime;
 
 extern crate zoneinfo_parse;
 use zoneinfo_parse::{Line, TableBuilder, Table, Structure, Child};
@@ -105,7 +105,7 @@ impl DataCrate {
         let base_mod_path = self.base_path.join("mod.rs");
         let mut base_w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(base_mod_path));
         try!(writeln!(base_w, "{}", WARNING_HEADER));
-        try!(writeln!(base_w, "{}", ZONEINFO_HEADER));
+        try!(writeln!(base_w, "{}", MOD_HEADER));
 
         for entry in self.table.structure() {
             if !entry.name.contains('/') {
@@ -219,5 +219,9 @@ const WARNING_HEADER: &'static str = r##"
 "##;
 
 const ZONEINFO_HEADER: &'static str = r##"
-use datetime::zoned::zoned::*;
+use datetime::zone::{TimeZone, FixedTimespanSet, FixedTimespan};
+"##;
+
+const MOD_HEADER: &'static str = r##"
+use datetime::zone::TimeZone;
 "##;
diff --git a/src/line.rs b/src/line.rs
index f8f28fd..f1392e2 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -1,8 +1,8 @@
 use std::ascii::AsciiExt;
 use std::str::FromStr;
 
-use datetime::local::{self, LocalDate, LocalTime, LocalDateTime};
-use datetime::zoned::TimeType;
+use datetime::{LocalDate, LocalTime, LocalDateTime, Month, Weekday};
+use datetime::zone::TimeType;
 
 use regex::{Regex, Captures};
 
@@ -330,9 +330,9 @@ impl ZoneTime {
         use self::TimeSpec::*;
 
         match *self {
-            UntilYear(Number(y))       => LocalDateTime::new(LocalDate::ymd(y, local::Month::January, 1).unwrap(), LocalTime::midnight()),
-            UntilMonth(Number(y), m)   => LocalDateTime::new(LocalDate::ymd(y, m.0, 1).unwrap(),                   LocalTime::midnight()),
-            UntilDay(Number(y), m, d)  => LocalDateTime::new(d.to_concrete_date(y, m.0),                           LocalTime::midnight()),
+            UntilYear(Number(y))       => LocalDateTime::new(LocalDate::ymd(y, Month::January, 1).unwrap(), LocalTime::midnight()),
+            UntilMonth(Number(y), m)   => LocalDateTime::new(LocalDate::ymd(y, m.0, 1).unwrap(),            LocalTime::midnight()),
+            UntilDay(Number(y), m, d)  => LocalDateTime::new(d.to_concrete_date(y, m.0),                    LocalTime::midnight()),
 
             UntilTime(Number(y), m, d, time) => {
                 let local_time = match time.0 {
@@ -419,9 +419,9 @@ impl FromStr for YearSpec {
 
 
 /// A **month** field, which is actually just a wrapper around
-/// `datetime::local::Month`.
+/// `datetime::Month`.
 #[derive(PartialEq, Debug, Copy, Clone)]
-pub struct MonthSpec(pub local::Month);
+pub struct MonthSpec(pub Month);
 
 impl FromStr for MonthSpec {
     type Err = Error;
@@ -429,18 +429,18 @@ impl FromStr for MonthSpec {
     /// Attempts to parse the given string into a value of this type.
     fn from_str(input: &str) -> Result<MonthSpec, Self::Err> {
         Ok(match &*input.to_ascii_lowercase() {
-            "jan" | "january"    => MonthSpec(local::Month::January),
-            "feb" | "february"   => MonthSpec(local::Month::February),
-            "mar" | "march"      => MonthSpec(local::Month::March),
-            "apr" | "april"      => MonthSpec(local::Month::April),
-            "may"                => MonthSpec(local::Month::May),
-            "jun" | "june"       => MonthSpec(local::Month::June),
-            "jul" | "july"       => MonthSpec(local::Month::July),
-            "aug" | "august"     => MonthSpec(local::Month::August),
-            "sep" | "september"  => MonthSpec(local::Month::September),
-            "oct" | "october"    => MonthSpec(local::Month::October),
-            "nov" | "november"   => MonthSpec(local::Month::November),
-            "dec" | "december"   => MonthSpec(local::Month::December),
+            "jan" | "january"    => MonthSpec(Month::January),
+            "feb" | "february"   => MonthSpec(Month::February),
+            "mar" | "march"      => MonthSpec(Month::March),
+            "apr" | "april"      => MonthSpec(Month::April),
+            "may"                => MonthSpec(Month::May),
+            "jun" | "june"       => MonthSpec(Month::June),
+            "jul" | "july"       => MonthSpec(Month::July),
+            "aug" | "august"     => MonthSpec(Month::August),
+            "sep" | "september"  => MonthSpec(Month::September),
+            "oct" | "october"    => MonthSpec(Month::October),
+            "nov" | "november"   => MonthSpec(Month::November),
+            "dec" | "december"   => MonthSpec(Month::December),
                   _              => return Err(Error::Fail),
         })
     }
@@ -448,9 +448,9 @@ impl FromStr for MonthSpec {
 
 
 /// A **weekday** field, which is actually just a wrapper around
-/// `datetime::local::Weekday`.
+/// `datetime::Weekday`.
 #[derive(PartialEq, Debug, Copy, Clone)]
-pub struct WeekdaySpec(pub local::Weekday);
+pub struct WeekdaySpec(pub Weekday);
 
 impl FromStr for WeekdaySpec {
     type Err = Error;
@@ -458,13 +458,13 @@ impl FromStr for WeekdaySpec {
     fn from_str(input: &str) -> Result<WeekdaySpec, Self::Err> {
 
         Ok(match &*input.to_ascii_lowercase() {
-            "mon" | "monday"     => WeekdaySpec(local::Weekday::Monday),
-            "tue" | "tuesday"    => WeekdaySpec(local::Weekday::Tuesday),
-            "wed" | "wednesday"  => WeekdaySpec(local::Weekday::Wednesday),
-            "thu" | "thursday"   => WeekdaySpec(local::Weekday::Thursday),
-            "fri" | "friday"     => WeekdaySpec(local::Weekday::Friday),
-            "sat" | "saturday"   => WeekdaySpec(local::Weekday::Saturday),
-            "sun" | "sunday"     => WeekdaySpec(local::Weekday::Sunday),
+            "mon" | "monday"     => WeekdaySpec(Weekday::Monday),
+            "tue" | "tuesday"    => WeekdaySpec(Weekday::Tuesday),
+            "wed" | "wednesday"  => WeekdaySpec(Weekday::Wednesday),
+            "thu" | "thursday"   => WeekdaySpec(Weekday::Thursday),
+            "fri" | "friday"     => WeekdaySpec(Weekday::Friday),
+            "sat" | "saturday"   => WeekdaySpec(Weekday::Saturday),
+            "sun" | "sunday"     => WeekdaySpec(Weekday::Sunday),
                   _              => return Err(Error::Fail),
         })
     }
@@ -501,8 +501,9 @@ impl DaySpec {
 
     /// Converts this day specification to a concrete date, given the year and
     /// month it should occur in.
-    pub fn to_concrete_date(&self, year: i64, month: local::Month) -> LocalDate {
-        use datetime::local::{LocalDate, Year, DatePiece};
+    pub fn to_concrete_date(&self, year: i64, month: Month) -> LocalDate {
+        use datetime::{LocalDate, DatePiece};
+        use datetime::iter::Year;
 
         match *self {
             DaySpec::Ordinal(day)           => LocalDate::ymd(year, month, day).unwrap(),
@@ -516,7 +517,7 @@ impl DaySpec {
     /// Panics if it can't find one. It should find one!
     fn find_weekday<I>(weekday: WeekdaySpec, mut iterator: I) -> LocalDate
     where I: Iterator<Item=LocalDate> {
-        use datetime::local::DatePiece;
+        use datetime::DatePiece;
 
         iterator.find(|date| date.weekday() == weekday.0)
                 .expect("Failed to find weekday")
@@ -738,14 +739,14 @@ mod test {
 
     mod rules {
         use super::*;
-        use datetime::zoned::zoneinfo::TimeType;
+        use datetime::zone::TimeType;
 
         test!(rule_1: "Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D" => Ok(Line::Rule(Rule {
             name:         "US",
             from_year:    YearSpec::Number(1967),
             to_year:      Some(YearSpec::Number(1973)),
-            month:        MonthSpec(local::Month::April),
-            day:          DaySpec::Last(WeekdaySpec(local::Weekday::Sunday)),
+            month:        MonthSpec(Month::April),
+            day:          DaySpec::Last(WeekdaySpec(Weekday::Sunday)),
             time:         TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall),
             time_to_add:  TimeSpec::HoursMinutes(1, 0),
             letters:      Some("D"),
@@ -766,8 +767,8 @@ mod test {
             name:        "EU",
             from_year:    YearSpec::Number(1977),
             to_year:      Some(YearSpec::Number(1980)),
-            month:        MonthSpec(local::Month::April),
-            day:          DaySpec::FirstOnOrAfter(WeekdaySpec(local::Weekday::Sunday), 1),
+            month:        MonthSpec(Month::April),
+            day:          DaySpec::FirstOnOrAfter(WeekdaySpec(Weekday::Sunday), 1),
             time:         TimeSpec::HoursMinutes(1, 0).with_type(TimeType::UTC),
             time_to_add:  TimeSpec::HoursMinutes(1, 0),
             letters:      Some("S"),
@@ -779,7 +780,7 @@ mod test {
 
     mod zones {
         use super::*;
-        use datetime::zoned::zoneinfo::TimeType;
+        use datetime::zone::TimeType;
 
         test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Ok(Line::Zone(Zone {
             name: "Australia/Adelaide",
diff --git a/src/table.rs b/src/table.rs
index 3f41f26..f2cb62e 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -1,8 +1,8 @@
 use std::collections::hash_map::{HashMap, Entry};
 
 use line::{self, YearSpec, MonthSpec, DaySpec, ZoneTime};
-use datetime::local::{LocalDateTime, LocalTime};
-use datetime::zoned::TimeType;
+use datetime::{LocalDateTime, LocalTime};
+use datetime::zone::TimeType;
 
 
 /// A table of all the data in one or more zoneinfo files.
@@ -106,7 +106,7 @@ impl Table {
                 },
 
                 Saving::Multiple(ref rules) => {
-                    use datetime::local::DatePiece;
+                    use datetime::DatePiece;
 
                     for year in 1800..2100 {
                         if use_until && year > LocalDateTime::at(timespan.end_time.unwrap().to_timestamp()).year() {
@@ -288,7 +288,7 @@ impl RuleInfo {
     }
 
     fn absolute_datetime(&self, year: i64, utc_offset: i64, dst_offset: i64) -> LocalDateTime {
-        use datetime::duration::Duration;
+        use datetime::Duration;
 
         let offset = match self.time_type {
             TimeType::UTC       => 0,
@@ -502,9 +502,9 @@ mod test {
     #![allow(unused_results)]
 
     use super::{Transition, Saving, ZoneInfo, RuleInfo, Ruleset, Table, Zoneset, Format, optimise};
-    use datetime::local::Weekday::*;
-    use datetime::local::Month::*;
-    use datetime::zoned::zoneinfo::TimeType;
+    use datetime::Weekday::*;
+    use datetime::Month::*;
+    use datetime::zone::TimeType;
     use line::DaySpec;
     use line::WeekdaySpec;
     use line::MonthSpec;

From 4eac23f53c2c93c0af02cee488bb136c8cc22238 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Wed, 11 Nov 2015 19:26:44 +0000
Subject: [PATCH 027/113] Fix lookup function's lifetime
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The ‘get’ function (that *will* be in the data crate’s root) was confused over the elided lifetimes of the ‘lookup’ function (in the data module). Adding an explicit 'static fixes this.
---
 bin/build-data-crate.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 89b488e..e33d720 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -147,7 +147,7 @@ impl DataCrate {
         }
 
         try!(writeln!(base_w, "\n\n"));
-        try!(writeln!(base_w, "pub fn lookup(input: &str) -> Option<TimeZone> {{"));
+        try!(writeln!(base_w, "pub fn lookup(input: &str) -> Option<TimeZone<'static>> {{"));
         for name in &keys {
             try!(writeln!(base_w, "    if input == {:?} {{", name));
             try!(writeln!(base_w, "        return Some({});", sanitise_name(name).replace("/", "::")));

From de220c76799a9a5dec3dcc6838fbde184d93e117 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Wed, 11 Nov 2015 21:51:19 +0000
Subject: [PATCH 028/113] Simple whitespace changes

---
 src/line.rs | 51 ++++++++++++++++++++++++++-------------------------
 1 file changed, 26 insertions(+), 25 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index f1392e2..6d26106 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -129,12 +129,12 @@ impl<'line> Rule<'line> {
     /// Attempts to parse the given string into a value of this type.
     fn from_str(input: &str) -> Result<Rule, Error> {
         if let Some(caps) = RULE_LINE.captures(input) {
-            let name         = caps.name("name").unwrap();
-            let from_year    = try!(caps.name("from").unwrap().parse());
+            let name      = caps.name("name").unwrap();
+            let from_year = try!(caps.name("from").unwrap().parse());
 
             // The end year can be 'only' to indicate that this rule only
             // takes place on that year.
-            let to_year      = match caps.name("to").unwrap() {
+            let to_year = match caps.name("to").unwrap() {
                 "only"  => None,
                 to      => Some(try!(to.parse())),
             };
@@ -148,11 +148,11 @@ impl<'line> Rule<'line> {
                 return Err(Error::Fail);
             }
 
-            let month         = try!(caps.name("in").unwrap().parse());
-            let day           = try!(caps.name("on").unwrap().parse());
-            let time          = try!(caps.name("at").unwrap().parse());
-            let time_to_add   = try!(caps.name("save").unwrap().parse());
-            let letters       = match caps.name("letters").unwrap() {
+            let month        = try!(caps.name("in").unwrap().parse());
+            let day          = try!(caps.name("on").unwrap().parse());
+            let time         = try!(caps.name("at").unwrap().parse());
+            let time_to_add  = try!(caps.name("save").unwrap().parse());
+            let letters      = match caps.name("letters").unwrap() {
                 "-"  => None,
                 l    => Some(l),
             };
@@ -203,6 +203,24 @@ pub struct Zone<'line> {
     pub info: ZoneInfo<'line>,
 }
 
+impl<'line> Zone<'line> {
+    fn from_str(input: &str) -> Result<Zone, Error> {
+        if let Some(caps) = ZONE_LINE.captures(input) {
+            let name = caps.name("name").unwrap();
+            let info = try!(ZoneInfo::from_captures(caps));
+
+            Ok(Zone {
+                name: name,
+                info: info,
+            })
+        }
+        else {
+            Err(Error::Fail)
+        }
+    }
+}
+
+
 /// The information contained in both zone lines *and* zone continuation lines.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub struct ZoneInfo<'line> {
@@ -222,23 +240,6 @@ pub struct ZoneInfo<'line> {
     pub time: Option<ZoneTime>,
 }
 
-impl<'line> Zone<'line> {
-    fn from_str(input: &str) -> Result<Zone, Error> {
-        if let Some(caps) = ZONE_LINE.captures(input) {
-            let name = caps.name("name").unwrap();
-            let info = try!(ZoneInfo::from_captures(caps));
-
-            Ok(Zone {
-                name: name,
-                info: info,
-            })
-        }
-        else {
-            Err(Error::Fail)
-        }
-    }
-}
-
 impl<'line> ZoneInfo<'line> {
     fn from_captures(caps: Captures<'line>) -> Result<ZoneInfo<'line>, Error> {
         let utc_offset    = try!(caps.name("gmtoff").unwrap().parse());

From e5cbf7f9f805a8e180f007c1e68dc850f918f31b Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 12 Nov 2015 12:41:53 +0000
Subject: [PATCH 029/113] Return to using the Git version of datetime

---
 Cargo.toml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 91ddd77..f94f634 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,6 +8,8 @@ name = "build-data-crate"
 path = "bin/build-data-crate.rs"
 
 [dependencies]
-datetime = "*"
 lazy_static = "*"
 regex = "*"
+
+[dependencies.datetime]
+git = "https://github.com/rust-datetime/datetime.git"

From 0ec5b7744a9bcda698f4b11fcc31acbee8a40a70 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 12 Nov 2015 16:32:14 +0000
Subject: [PATCH 030/113] Fix tests for Travis
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Update nomenclature in test code (FixedTimespan, FixedTimespanSet, no more Transition)
- Add local mean times to the rules tests to make them stop failing (it’ll never be valid to have a time zone that *begins* with a rule—it should always have a local mean time first!)
- Removed the only feature flag to remove dependence on Rust Nightly
---
 bin/build-data-crate.rs |   2 +-
 src/lib.rs              |   4 +-
 src/line.rs             |  14 +-
 src/table.rs            | 305 ++++++++++++++++++++--------------------
 4 files changed, 162 insertions(+), 163 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index e33d720..18358b9 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -171,7 +171,7 @@ impl DataCrate {
             try!(writeln!(w, "    name: {:?},", name));
             try!(writeln!(w, "    fixed_timespans: FixedTimespanSet {{"));
 
-            let set = self.table.transitions(&*name);
+            let set = self.table.timespans(&*name);
 
             try!(writeln!(w, "        first: FixedTimespan {{"));
             try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", set.first.total_offset(), set.first.utc_offset, set.first.dst_offset));
diff --git a/src/lib.rs b/src/lib.rs
index 44ddffe..ce5bd0b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,7 +1,5 @@
 //! Parsing Olson DB formats.
 
-#![feature(iter_cmp)]
-
 #![warn(missing_copy_implementations)]
 #![warn(missing_debug_implementations)]
 //#![warn(missing_docs)]
@@ -17,7 +15,7 @@ mod line;
 pub use line::Line;
 
 mod table;
-pub use table::{Table, TableBuilder, Saving, ZoneSet, ZoneDetails};
+pub use table::{Table, TableBuilder, Saving, FixedTimespanSet, FixedTimespan};
 
 mod structure;
 pub use structure::*;
\ No newline at end of file
diff --git a/src/line.rs b/src/line.rs
index 6d26106..ccebf06 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -724,7 +724,7 @@ impl<'line> Line<'line> {
 mod test {
     pub use std::str::FromStr;
     pub use super::*;
-    pub use datetime::local;
+    pub use datetime::{Weekday, Month};
 
     macro_rules! test {
         ($name:ident: $input:expr => $result:expr) => {
@@ -757,7 +757,7 @@ mod test {
             name:         "Greece",
             from_year:    YearSpec::Number(1976),
             to_year:      None,
-            month:        MonthSpec(local::Month::October),
+            month:        MonthSpec(Month::October),
             day:          DaySpec::Ordinal(10),
             time:         TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Standard),
             time_to_add:  TimeSpec::Hours(0),
@@ -789,7 +789,7 @@ mod test {
                 utc_offset:  TimeSpec::HoursMinutes(9, 30),
                 saving:      Saving::Multiple("Aus"),
                 format:      "AC%sT",
-                time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
+                time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
             },
         })));
 
@@ -797,14 +797,14 @@ mod test {
             utc_offset:  TimeSpec::HoursMinutes(9, 30),
             saving:      Saving::Multiple("Aus"),
             format:      "AC%sT",
-            time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(local::Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
+            time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
         })));
 
         test!(continuation_2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Ok(Line::Continuation(ZoneInfo {
             utc_offset:  TimeSpec::HoursMinutes(1, 00),
             saving:      Saving::Multiple("C-Eur"),
             format:      "CE%sT",
-            time:        Some(ZoneTime::UntilDay(YearSpec::Number(1943), MonthSpec(local::Month::October), DaySpec::Ordinal(25))),
+            time:        Some(ZoneTime::UntilDay(YearSpec::Number(1943), MonthSpec(Month::October), DaySpec::Ordinal(25))),
         })));
 
         test!(zone_hyphen: "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919" => Ok(Line::Zone(Zone {
@@ -825,8 +825,8 @@ mod test {
 
     #[test]
     fn month() {
-        assert_eq!(MonthSpec::from_str("Aug"), Ok(MonthSpec(local::Month::August)));
-        assert_eq!(MonthSpec::from_str("December"), Ok(MonthSpec(local::Month::December)));
+        assert_eq!(MonthSpec::from_str("Aug"), Ok(MonthSpec(Month::August)));
+        assert_eq!(MonthSpec::from_str("December"), Ok(MonthSpec(Month::December)));
     }
 
     test!(golb: "GOLB" => Err(Error::Fail));
diff --git a/src/table.rs b/src/table.rs
index f2cb62e..0e62335 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -23,26 +23,26 @@ pub struct Table {
 pub struct Ruleset(pub Vec<RuleInfo>);
 
 #[derive(PartialEq, Debug, Clone)]
-pub struct ZoneSet {
-    pub first: ZoneDetails,
-    pub rest: Vec<(i64, ZoneDetails)>,
+pub struct FixedTimespanSet {
+    pub first: FixedTimespan,
+    pub rest: Vec<(i64, FixedTimespan)>,
 }
 
 #[derive(PartialEq, Debug, Clone)]
-pub struct ZoneDetails {
+pub struct FixedTimespan {
     pub utc_offset: i64,
     pub dst_offset: i64,
     pub name:       String,
 }
 
-impl ZoneDetails {
+impl FixedTimespan {
     pub fn total_offset(&self) -> i64 {
         self.utc_offset + self.dst_offset
     }
 }
 
 impl Table {
-    pub fn transitions(&self, zone_name: &str) -> ZoneSet {
+    pub fn timespans(&self, zone_name: &str) -> FixedTimespanSet {
         let mut transitions = Vec::new();
         let mut start_time = None;
         let mut until_time = None;
@@ -66,7 +66,7 @@ impl Table {
                     start_zone_id = Some(timespan.format.format_constant());
 
                     if insert_start_transition {
-                        let t = (start_time.unwrap(), ZoneDetails {
+                        let t = (start_time.unwrap(), FixedTimespan {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
                             name:       start_zone_id.clone().unwrap_or("".to_string()),
@@ -75,7 +75,7 @@ impl Table {
                         insert_start_transition = false;
                     }
                     else {
-                        first_transition = Some(ZoneDetails {
+                        first_transition = Some(FixedTimespan {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
                             name:       start_zone_id.clone().unwrap_or("".to_string()),
@@ -88,7 +88,7 @@ impl Table {
                     start_zone_id = Some(timespan.format.format_constant());
 
                     if insert_start_transition {
-                        let t = (start_time.unwrap(), ZoneDetails {
+                        let t = (start_time.unwrap(), FixedTimespan {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
                             name:       start_zone_id.clone().unwrap_or("".to_string()),
@@ -97,7 +97,7 @@ impl Table {
                         insert_start_transition = false;
                     }
                     else {
-                        first_transition = Some(ZoneDetails {
+                        first_transition = Some(FixedTimespan {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
                             name:       start_zone_id.clone().unwrap_or("".to_string()),
@@ -122,13 +122,18 @@ impl Table {
                                 until_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - dst_offset);
                             }
 
+                            // Find the minimum rule based on the current UTC and DST offsets.
+                            // (this can be replaced with min_by when it stabilises):
+                            //.min_by(|r| r.1.absolute_datetime(year, utc_offset, dst_offset));
                             let pos = {
                                 let earliest = activated_rules.iter().enumerate()
-                                    .min_by(|r| r.1.absolute_datetime(year, utc_offset, dst_offset));
+                                    .map(|(i, r)| (r.absolute_datetime(year, utc_offset, dst_offset), i))
+                                    .min()
+                                    .map(|(_, i)| i);
 
                                 match earliest {
-                                    Some((p, _)) => p,
-                                    None         => break,
+                                    Some(p) => p,
+                                    None    => break,
                                 }
                             };
 
@@ -158,7 +163,7 @@ impl Table {
                                 }
                             }
 
-                            let t = (earliest_at, ZoneDetails {
+                            let t = (earliest_at, FixedTimespan {
                                 utc_offset: timespan.offset,
                                 dst_offset: earliest_rule.time_to_add,
                                 name:       timespan.format.format(earliest_rule.time_to_add, earliest_rule.letters.as_ref()),
@@ -169,17 +174,17 @@ impl Table {
                 }
             }
 
-            if insert_start_transition {
-                let t = (start_time.unwrap(), ZoneDetails {
+            if insert_start_transition && start_zone_id.is_some() {
+                let t = (start_time.expect("Start time"), FixedTimespan {
                     utc_offset: start_utc_offset,
                     dst_offset: start_dst_offset,
-                    name:       start_zone_id.clone().unwrap(),
+                    name:       start_zone_id.clone().expect("Start zone ID"),
                 });
                 transitions.push(t);
             }
 
             if use_until {
-                start_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - dst_offset);
+                start_time = Some(timespan.end_time.expect("End time").to_timestamp() - utc_offset - dst_offset);
             }
         }
 
@@ -190,7 +195,7 @@ impl Table {
             None     => transitions.iter().find(|t| t.1.dst_offset == 0).unwrap().1.clone(),
         };
 
-        let mut zoneset = ZoneSet {
+        let mut zoneset = FixedTimespanSet {
             first: first,
             rest:  transitions,
         };
@@ -200,7 +205,7 @@ impl Table {
 }
 
 #[allow(unused_results)]  // for remove
-fn optimise(transitions: &mut ZoneSet) {
+fn optimise(transitions: &mut FixedTimespanSet) {
     let mut from_i = 0;
     let mut to_i = 0;
 
@@ -501,7 +506,7 @@ mod test {
     // to be correct, otherwise the tests would fail!
     #![allow(unused_results)]
 
-    use super::{Transition, Saving, ZoneInfo, RuleInfo, Ruleset, Table, Zoneset, Format, optimise};
+    use super::{FixedTimespan, FixedTimespanSet, Saving, ZoneInfo, RuleInfo, Ruleset, Table, Zoneset, Format, optimise};
     use datetime::Weekday::*;
     use datetime::Month::*;
     use datetime::zone::TimeType;
@@ -524,14 +529,10 @@ mod test {
         let mut table = Table::default();
         table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone ]));
 
-        assert_eq!(table.transitions("Test/Zone"), vec![
-            Transition {
-                occurs_at:  None,
-                utc_offset: 1234,
-                dst_offset: 0,
-                name:       "TEST".to_owned(),
-            }
-        ]);
+        assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+            first: FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned() },
+            rest:  vec![],
+        });
     }
 
     #[test]
@@ -553,20 +554,14 @@ mod test {
         let mut table = Table::default();
         table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone_1, zone_2 ]));
 
-        assert_eq!(table.transitions("Test/Zone"), vec![
-            Transition {
-                occurs_at: None,
-                utc_offset: 1234,
-                dst_offset: 0,
-                name:       "TEST".to_owned(),
-            },
-            Transition {
-                occurs_at: Some(122222),
-                utc_offset: 5678,
-                dst_offset: 0,
-                name:       "TSET".to_owned(),
-            },
-        ]);
+        let expected = FixedTimespanSet {
+            first:       FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned() },
+            rest: vec![
+                (122222, FixedTimespan { utc_offset: 5678, dst_offset: 0, name: "TSET".to_owned() }),
+            ],
+        };
+
+        assert_eq!(table.timespans("Test/Zone"), expected);
     }
 
 
@@ -596,26 +591,23 @@ mod test {
         let mut table = Table::default();
         table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone_1, zone_2, zone_3 ]));
 
-        assert_eq!(table.transitions("Test/Zone"), vec![
-            Transition {
-                occurs_at: None,
-                utc_offset: 1234,
-                dst_offset: 0,
-                name: "TEST".to_owned(),
-            },
-            Transition {
-                occurs_at: Some(122222),
-                utc_offset: 3456,
-                dst_offset: 0,
-                name: "TSET".to_owned(),
-            },
-            Transition {
-                occurs_at: Some(231111),
-                utc_offset: 5678,
-                dst_offset: 0,
-                name: "ESTE".to_owned(),
-            },
-        ]);
+        let expected = FixedTimespanSet {
+            first: FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned(), },
+            rest: vec![
+                (122222, FixedTimespan {
+                    utc_offset: 3456,
+                    dst_offset: 0,
+                    name: "TSET".to_owned(),
+                }),
+                (231111, FixedTimespan {
+                    utc_offset: 5678,
+                    dst_offset: 0,
+                    name: "ESTE".to_owned(),
+                }),
+            ],
+        };
+
+        assert_eq!(table.timespans("Test/Zone"), expected);
     }
 
     #[test]
@@ -633,6 +625,13 @@ mod test {
             }
         ]);
 
+        let lmt = ZoneInfo {
+            offset: 0,
+            format: Format::new("LMT"),
+            saving: Saving::NoSaving,
+            end_time: Some(ZoneTime::UntilYear(YearSpec::Number(1980))),
+        };
+
         let zone = ZoneInfo {
             offset: 2000,
             format: Format::new("TEST"),
@@ -641,17 +640,15 @@ mod test {
         };
 
         let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone ]));
+        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ lmt, zone ]));
         table.rulesets.insert("Dwayne".to_owned(), ruleset);
 
-        assert_eq!(table.transitions("Test/Zone"), vec![
-            Transition {
-                occurs_at:  Some(318_470_400),
-                utc_offset: 2000,
-                dst_offset: 1000,
-                name:       "TEST".to_owned(),
-            },
-        ]);
+        assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+            first: FixedTimespan { utc_offset: 0, dst_offset: 0, name: "LMT".to_owned() },
+            rest:  vec![
+                (318_470_400, FixedTimespan { utc_offset: 2000, dst_offset: 1000, name: "TEST".to_owned() })
+            ],
+        });
     }
 
     #[test]
@@ -679,6 +676,13 @@ mod test {
             },
         ]);
 
+        let lmt = ZoneInfo {
+            offset: 0,
+            format: Format::new("LMT"),
+            saving: Saving::NoSaving,
+            end_time: Some(ZoneTime::UntilYear(YearSpec::Number(1980))),
+        };
+
         let zone = ZoneInfo {
             offset: 2000,
             format: Format::new("TEST"),
@@ -687,45 +691,38 @@ mod test {
         };
 
         let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone ]));
+        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ lmt, zone ]));
         table.rulesets.insert("Dwayne".to_owned(), ruleset);
 
-        assert_eq!(table.transitions("Test/Zone"), vec![
-            Transition {
-                occurs_at:  Some(318_470_400),
-                utc_offset: 2000,
-                dst_offset: 1000,
-                name:       "TEST".to_owned(),
-            },
-            Transition {
-                occurs_at:  Some(600_566_400),
-                utc_offset: 2000,
-                dst_offset: 1500,
-                name:       "TEST".to_owned(),
-            },
-        ]);
+        assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+            first: FixedTimespan { utc_offset: 0, dst_offset: 0, name: "LMT".to_owned() },
+            rest: vec![
+                (318_470_400, FixedTimespan { utc_offset: 2000, dst_offset: 1000, name: "TEST".to_owned() }),
+                (600_566_400, FixedTimespan { utc_offset: 2000, dst_offset: 1500, name: "TEST".to_owned() }),
+            ],
+        });
     }
 
     #[test]
     fn tripoli() {
         let libya = Ruleset(vec![
-            RuleInfo { from_year: YearSpec::Number(1951), to_year: None,               month: MonthSpec(October),   day: DaySpec::Ordinal(14),               time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1952), to_year: None,               month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(1953), to_year: None,               month: MonthSpec(October),   day: DaySpec::Ordinal(9),                time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1954), to_year: None,               month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(1955), to_year: None,               month: MonthSpec(September), day: DaySpec::Ordinal(30),               time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1956), to_year: None,               month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1951), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(14),               time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1952), to_year: None,                         month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1953), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(9),                time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1954), to_year: None,                         month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1955), to_year: None,                         month: MonthSpec(September), day: DaySpec::Ordinal(30),               time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1956), to_year: None,                         month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
             RuleInfo { from_year: YearSpec::Number(1982), to_year: Some(YearSpec::Number(1984)), month: MonthSpec(April),     day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
             RuleInfo { from_year: YearSpec::Number(1982), to_year: Some(YearSpec::Number(1985)), month: MonthSpec(October),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(1985), to_year: None,               month: MonthSpec(April),     day: DaySpec::Ordinal(6),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1986), to_year: None,               month: MonthSpec(April),     day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1986), to_year: None,               month: MonthSpec(October),   day: DaySpec::Ordinal(3),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1985), to_year: None,                         month: MonthSpec(April),     day: DaySpec::Ordinal(6),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1986), to_year: None,                         month: MonthSpec(April),     day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1986), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(3),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
             RuleInfo { from_year: YearSpec::Number(1987), to_year: Some(YearSpec::Number(1989)), month: MonthSpec(April),     day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
             RuleInfo { from_year: YearSpec::Number(1987), to_year: Some(YearSpec::Number(1989)), month: MonthSpec(October),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(1997), to_year: None,               month: MonthSpec(April),     day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1997), to_year: None,               month: MonthSpec(October),   day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(2013), to_year: None,               month: MonthSpec(March),     day: DaySpec::Last(WeekdaySpec(Friday)), time: 3600, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(2013), to_year: None,               month: MonthSpec(October),   day: DaySpec::Last(WeekdaySpec(Friday)), time: 7200, time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(1997), to_year: None,                         month: MonthSpec(April),     day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(1997), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+            RuleInfo { from_year: YearSpec::Number(2013), to_year: None,                         month: MonthSpec(March),     day: DaySpec::Last(WeekdaySpec(Friday)), time: 3600, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+            RuleInfo { from_year: YearSpec::Number(2013), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Last(WeekdaySpec(Friday)), time: 7200, time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
         ]);
 
         let zone = vec![
@@ -744,64 +741,68 @@ mod test {
         table.zonesets.insert("Test/Zone".to_owned(), Zoneset(zone));
         table.rulesets.insert("Libya".to_owned(), libya);
 
-        assert_eq!(table.transitions("Test/Zone"), vec![
-            Transition { utc_offset: 3164, dst_offset: 0,    occurs_at: None,                 name:  "LMT".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(-1_577_926_364), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -574_902_000), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -568_087_200), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -512_175_600), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -504_928_800), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(  -449_888_400), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(  -441_856_800), name:  "CET".to_owned() },
-            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(  -347_158_800), name:  "EET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   378_684_000), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   386_463_600), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   402_271_200), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   417_999_600), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   433_807_200), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   449_622_000), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   465_429_600), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   481_590_000), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   496_965_600), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   512_953_200), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   528_674_400), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   544_230_000), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   560_037_600), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   575_852_400), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   591_660_000), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   607_388_400), name: "CEST".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   623_196_000), name:  "CET".to_owned() },
-            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(   641_775_600), name:  "EET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some(   844_034_400), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some(   860_108_400), name: "CEST".to_owned() },
-            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some(   875_916_000), name:  "EET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 0,    occurs_at: Some( 1_352_505_600), name:  "CET".to_owned() },
-            Transition { utc_offset: 3600, dst_offset: 3600, occurs_at: Some( 1_364_515_200), name: "CEST".to_owned() },
-            Transition { utc_offset: 7200, dst_offset: 0,    occurs_at: Some( 1_382_659_200), name:  "EET".to_owned() },
-        ]);
+        assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+            first: FixedTimespan { utc_offset: 3164,  dst_offset:    0,  name:  "LMT".to_owned() },
+            rest: vec![
+                (-1_577_926_364, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (  -574_902_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (  -568_087_200, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (  -512_175_600, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (  -504_928_800, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (  -449_888_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (  -441_856_800, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (  -347_158_800, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
+                (   378_684_000, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (   386_463_600, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (   402_271_200, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (   417_999_600, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (   433_807_200, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (   449_622_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (   465_429_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (   481_590_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (   496_965_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (   512_953_200, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (   528_674_400, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (   544_230_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (   560_037_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (   575_852_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (   591_660_000, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (   607_388_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (   623_196_000, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (   641_775_600, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
+                (   844_034_400, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                (   860_108_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                (   875_916_000, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
+                ( 1_352_505_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+                ( 1_364_515_200, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+                ( 1_382_659_200, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
+            ],
+        });
     }
 
     #[test]
     fn optimise_macquarie() {
-        let mut transitions = vec![
-            Transition { occurs_at: None,              utc_offset:     0, dst_offset:    0, name:  "zzz".to_owned() },
-            Transition { occurs_at: Some(-2214259200), utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },
-            Transition { occurs_at: Some(-1680508800), utc_offset: 36000, dst_offset: 3600, name: "AEDT".to_owned() },
-            Transition { occurs_at: Some(-1669892400), utc_offset: 36000, dst_offset: 3600, name: "AEDT".to_owned() },  // gets removed
-            Transition { occurs_at: Some(-1665392400), utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },
-            Transition { occurs_at: Some(-1601719200), utc_offset:     0, dst_offset:    0, name:  "zzz".to_owned() },
-            Transition { occurs_at: Some(-687052800),  utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },
-            Transition { occurs_at: Some(-94730400),   utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },  // also gets removed
-            Transition { occurs_at: Some(-71136000),   utc_offset: 36000, dst_offset: 3600, name: "AEDT".to_owned() },
-            Transition { occurs_at: Some(-55411200),   utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },
-            Transition { occurs_at: Some(-37267200),   utc_offset: 36000, dst_offset: 3600, name: "AEDT".to_owned() },
-            Transition { occurs_at: Some(-25776000),   utc_offset: 36000, dst_offset:    0, name: "AEST".to_owned() },
-            Transition { occurs_at: Some(-5817600),    utc_offset: 36000, dst_offset: 3600, name: "AEDT".to_owned() },
-        ];
+        let mut transitions = FixedTimespanSet {
+            first: FixedTimespan { utc_offset:     0, dst_offset:    0, name:  "zzz".to_owned() },
+            rest: vec![
+                (-2_214_259_200, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (-1_680_508_800, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+                (-1_669_892_400, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),  // gets removed
+                (-1_665_392_400, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (-1_601_719_200, FixedTimespan { utc_offset:     0,  dst_offset:    0,  name:  "zzz".to_owned() }),
+                (  -687_052_800, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (   -94_730_400, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),  // also gets removed
+                (   -71_136_000, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+                (   -55_411_200, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (   -37_267_200, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+                (   -25_776_000, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (    -5_817_600, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+            ],
+        };
 
         let mut result = transitions.clone();
-        result.remove(7);
-        result.remove(3);
+        result.rest.remove(6);
+        result.rest.remove(2);
 
         optimise(&mut transitions);
         assert_eq!(transitions, result);

From 12277b77951628040ff1378eed323555bb38be19 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 13 Nov 2015 12:55:37 +0000
Subject: [PATCH 031/113] Comment improvements

---
 bin/build-data-crate.rs |   2 +-
 src/lib.rs              |   3 +-
 src/line.rs             | 101 ++++++++++++++---------
 src/structure.rs        |  89 +++++++++++---------
 src/table.rs            | 178 +++++++++++++++++++++++++++++-----------
 5 files changed, 242 insertions(+), 131 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 18358b9..10311b4 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -123,7 +123,7 @@ impl DataCrate {
             let mut w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(mod_path));
             for child in &entry.children {
                 match *child {
-                    Child::Ruleset(ref name) => {
+                    Child::TimeZone(ref name) => {
                         let sanichild = sanitise_name(name);
                         try!(writeln!(w, "mod {};", sanichild));
                         try!(writeln!(w, "pub use self::{}::ZONE as {};\n", sanichild, sanichild));
diff --git a/src/lib.rs b/src/lib.rs
index ce5bd0b..368b262 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,7 +2,8 @@
 
 #![warn(missing_copy_implementations)]
 #![warn(missing_debug_implementations)]
-//#![warn(missing_docs)]
+#![warn(missing_docs)]
+
 #![warn(trivial_casts, trivial_numeric_casts)]
 #![warn(unused_qualifications)]
 #![warn(unused_results)]
diff --git a/src/line.rs b/src/line.rs
index ccebf06..fb65ee0 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -1,3 +1,13 @@
+//! Parsing zoneinfo data files, line-by-line.
+//!
+//! This module provides functions that take a line of input from a zoneinfo
+//! data file and attempts to parse it, returning the details of the line if
+//! it gets parsed successfully. It classifies them as `Rule`, `Link`,
+//! `Zone`, or `Continuation` lines.
+//!
+//! The actual *interpretation* of what the details mean is done by the
+//! `table` module.
+
 use std::ascii::AsciiExt;
 use std::str::FromStr;
 
@@ -46,7 +56,7 @@ lazy_static! {
         ( ?P<flag> [wsugz] )?
     $ "##).unwrap();
 
-    // ^ those two could be done with the same regex, but... they aren't.
+    // ^ those two could be done with the same regex, but... they aren‘t.
 
     /// Format of a Zone line, with one capturing group per field.
     static ref ZONE_LINE: Regex = Regex::new(r##"(?x) ^
@@ -104,7 +114,7 @@ pub struct Rule<'line> {
     /// The first year in which the rule applies.
     pub from_year: YearSpec,
 
-    /// The final year, or `None` if's 'only'.
+    /// The final year, or `None` if’s ‘only’.
     pub to_year: Option<YearSpec>,
 
     /// The month in which the rule takes effect.
@@ -132,17 +142,17 @@ impl<'line> Rule<'line> {
             let name      = caps.name("name").unwrap();
             let from_year = try!(caps.name("from").unwrap().parse());
 
-            // The end year can be 'only' to indicate that this rule only
+            // The end year can be ‘only’ to indicate that this rule only
             // takes place on that year.
             let to_year = match caps.name("to").unwrap() {
                 "only"  => None,
                 to      => Some(try!(to.parse())),
             };
 
-            // According to the spec, the only value inside the 'type' column
-            // should be "-", so throw an error if it isn't. (It only exists
+            // According to the spec, the only value inside the ‘type’ column
+            // should be “-”, so throw an error if it isn’t. (It only exists
             // for compatibility with old versions that used to contain year
-            // types.) Sometimes "‐", a Unicode hyphen, is used as well.
+            // types.) Sometimes “‐”, a Unicode hyphen, is used as well.
             let t = caps.name("type").unwrap();
             if t != "-" && t != "\u{2010}"  {
                 return Err(Error::Fail);
@@ -174,6 +184,7 @@ impl<'line> Rule<'line> {
     }
 }
 
+
 /// A **zone** definition line.
 ///
 /// According to the `zic(8)` man page, a zone line has this form, along with
@@ -185,7 +196,7 @@ impl<'line> Rule<'line> {
 /// ```
 ///
 /// The opening `Zone` identifier is ignored, and the last four columns are
-/// all optional, with their variants consolidated into a `ZoneTime`.
+/// all optional, with their variants consolidated into a `ChangeTime`.
 ///
 /// The `Rules/Save` column, if it contains a value, *either* contains the
 /// name of the rules to use for this zone, *or* contains a one-off period of
@@ -225,8 +236,8 @@ impl<'line> Zone<'line> {
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub struct ZoneInfo<'line> {
 
-    /// The amount of time to be added to Universal TimeSpec, to get standard time
-    /// in this zone.
+    /// The amount of time that needs to be added to UTC to get the standard
+    /// time in this zone.
     pub utc_offset: TimeSpec,
 
     /// The name of all the rules that should apply in the time zone, or the
@@ -236,8 +247,9 @@ pub struct ZoneInfo<'line> {
     /// The format for time zone abbreviations, with `%s` as the string marker.
     pub format: &'line str,
 
-    /// The time at which the rules change for this location, or `None` if these rules
-    pub time: Option<ZoneTime>,
+    /// The time at which the rules change for this location, or `None` if
+    /// these rules are in effect until the end of time (!).
+    pub time: Option<ChangeTime>,
 }
 
 impl<'line> ZoneInfo<'line> {
@@ -250,10 +262,10 @@ impl<'line> ZoneInfo<'line> {
         // that it should be impossible to, say, have a defined month but not
         // a defined year.
         let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
-            (Some(y), Some(m), Some(d), Some(t)) => Some(ZoneTime::UntilTime  (try!(y.parse()), try!(m.parse()), try!(d.parse()), try!(t.parse()))),
-            (Some(y), Some(m), Some(d), _      ) => Some(ZoneTime::UntilDay   (try!(y.parse()), try!(m.parse()), try!(d.parse()))),
-            (Some(y), Some(m), _      , _      ) => Some(ZoneTime::UntilMonth (try!(y.parse()), try!(m.parse()))),
-            (Some(y), _      , _      , _      ) => Some(ZoneTime::UntilYear  (try!(y.parse()))),
+            (Some(y), Some(m), Some(d), Some(t)) => Some(ChangeTime::UntilTime  (try!(y.parse()), try!(m.parse()), try!(d.parse()), try!(t.parse()))),
+            (Some(y), Some(m), Some(d), _      ) => Some(ChangeTime::UntilDay   (try!(y.parse()), try!(m.parse()), try!(d.parse()))),
+            (Some(y), Some(m), _      , _      ) => Some(ChangeTime::UntilMonth (try!(y.parse()), try!(m.parse()))),
+            (Some(y), _      , _      , _      ) => Some(ChangeTime::UntilYear  (try!(y.parse()))),
             (None   , None   , None   , None   ) => None,
             _                                    => unreachable!("Out-of-order capturing groups!"),
         };
@@ -306,9 +318,14 @@ impl<'line> Saving<'line> {
 }
 
 
-/// The time at which the rules change for a location, with varying degrees of precision.
+/// The time at which the rules change for a location.
+///
+/// This is described with as few units as possible: a change that occurs at
+/// the beginning of the year lists only the year, a change that occurs on a
+/// particular day has to list the year, month, and day, and one that occurs
+/// at a particular second has to list everything.
 #[derive(PartialEq, Debug, Copy, Clone)]
-pub enum ZoneTime {
+pub enum ChangeTime {
 
     /// The earliest point in a particular **year**.
     UntilYear(YearSpec),
@@ -319,16 +336,17 @@ pub enum ZoneTime {
     /// The earliest point in a particular **day**.
     UntilDay(YearSpec, MonthSpec, DaySpec),
 
-    /// The earliest point in a particular hour, minute, or second, or one of
-    /// those small time units, anyway.
+    /// The earliest point in a particular **hour, minute, or second**.
     UntilTime(YearSpec, MonthSpec, DaySpec, TimeSpecAndType),
 }
 
-impl ZoneTime {
+impl ChangeTime {
+
+    /// Convert this change time to an absolute timestamp, as the number of
+    /// seconds since the Unix epoch that the change occurs at.
     pub fn to_timestamp(&self) -> i64 {
-        use self::ZoneTime::*;
+        use self::ChangeTime::*;
         use self::YearSpec::Number;
-        use self::TimeSpec::*;
 
         match *self {
             UntilYear(Number(y))       => LocalDateTime::new(LocalDate::ymd(y, Month::January, 1).unwrap(), LocalTime::midnight()),
@@ -337,10 +355,10 @@ impl ZoneTime {
 
             UntilTime(Number(y), m, d, time) => {
                 let local_time = match time.0 {
-                    Zero                          => LocalTime::midnight(),
-                    Hours(h)                      => LocalTime::hms(h, 0, 0).unwrap(),
-                    HoursMinutes(h, mm)           => LocalTime::hms(h, mm, 0).unwrap(),
-                    HoursMinutesSeconds(h, mm, s) => LocalTime::hms(h, mm, s).unwrap(),
+                    TimeSpec::Zero                          => LocalTime::midnight(),
+                    TimeSpec::Hours(h)                      => LocalTime::hms(h, 0, 0).unwrap(),
+                    TimeSpec::HoursMinutes(h, mm)           => LocalTime::hms(h, mm, 0).unwrap(),
+                    TimeSpec::HoursMinutesSeconds(h, mm, s) => LocalTime::hms(h, mm, s).unwrap(),
                 };
 
                 LocalDateTime::new(d.to_concrete_date(y, m.0), local_time)
@@ -474,11 +492,11 @@ impl FromStr for WeekdaySpec {
 
 /// A **day** definition field.
 ///
-/// This can be given in either absolute terms (such as "the fifth day of the
-/// month"), or relative terms (such as "the last Sunday of the month", or
-/// "the last Friday before or including the 13th").
+/// This can be given in either absolute terms (such as “the fifth day of the
+/// month”), or relative terms (such as “the last Sunday of the month”, or
+/// “the last Friday before or including the 13th”).
 ///
-/// Note that in the last example, it's allowed for that particular Friday to
+/// Note that in the last example, it’s allowed for that particular Friday to
 /// *be* the 13th in question.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub enum DaySpec {
@@ -515,7 +533,7 @@ impl DaySpec {
     }
 
     /// Find the first-occurring day with the given weekday in the iterator.
-    /// Panics if it can't find one. It should find one!
+    /// Panics if it can’t find one. It should find one!
     fn find_weekday<I>(weekday: WeekdaySpec, mut iterator: I) -> LocalDate
     where I: Iterator<Item=LocalDate> {
         use datetime::DatePiece;
@@ -535,14 +553,14 @@ impl FromStr for DaySpec {
             Ok(DaySpec::Ordinal(input.parse().unwrap()))
         }
 
-        // Check if it stars with 'last', and trim off the first four bytes if
-        // it does. (Luckily, the file is ASCII.)
+        // Check if it stars with ‘last’, and trim off the first four bytes if
+        // it does. (Luckily, the file is ASCII, so ‘last’ is four bytes)
         else if input.starts_with("last") {
             let weekday = try!(input[4..].parse());
             Ok(DaySpec::Last(weekday))
         }
 
-        // Check if it's a relative expression with the regex.
+        // Check if it’s a relative expression with the regex.
         else if let Some(caps) = DAY_FIELD.captures(input) {
             let weekday = caps.name("weekday").unwrap().parse().unwrap();
             let day     = caps.name("day").unwrap().parse().unwrap();
@@ -565,7 +583,7 @@ impl FromStr for DaySpec {
 /// A **time** definition field.
 ///
 /// A time must have an hours component, with optional minutes and seconds
-/// components. It can also be negative with a starting '-'.
+/// components. It can also be negative with a starting ‘-’.
 ///
 /// Hour 0 is midnight at the start of the day, and Hour 24 is midnight at the
 /// end of the day.
@@ -593,6 +611,7 @@ pub struct TimeSpecAndType(pub TimeSpec, pub TimeType);
 
 impl TimeSpec {
 
+    /// Shorthand `TimeSpecAndType` constructor for testing.
     #[cfg(test)]
     pub fn with_type(self, time_type: TimeType) -> TimeSpecAndType {
         TimeSpecAndType(self, time_type)
@@ -655,6 +674,7 @@ impl FromStr for TimeSpec {
     }
 }
 
+/// Select which time type to use based on a timestamp’s suffix.
 fn parse_time_type(c: &str) -> Option<TimeType> {
     Some(match c {
         "w"             => TimeType::Wall,
@@ -696,7 +716,8 @@ pub enum Line<'line> {
 
 impl<'line> Line<'line> {
 
-    /// Attempts to parse the given string into a value of this type.
+    /// Attempt to parse this line, returning a `Line` depending on what
+    /// type of line it was, or an `Error` if it couldn't be parsed.
     pub fn from_str(input: &str) -> Result<Line, Error> {
         if input.is_empty() || input.chars().all(char::is_whitespace) {
             Ok(Line::Space)
@@ -789,7 +810,7 @@ mod test {
                 utc_offset:  TimeSpec::HoursMinutes(9, 30),
                 saving:      Saving::Multiple("Aus"),
                 format:      "AC%sT",
-                time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
+                time:        Some(ChangeTime::UntilTime(YearSpec::Number(1971), MonthSpec(Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
             },
         })));
 
@@ -797,14 +818,14 @@ mod test {
             utc_offset:  TimeSpec::HoursMinutes(9, 30),
             saving:      Saving::Multiple("Aus"),
             format:      "AC%sT",
-            time:        Some(ZoneTime::UntilTime(YearSpec::Number(1971), MonthSpec(Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
+            time:        Some(ChangeTime::UntilTime(YearSpec::Number(1971), MonthSpec(Month::October), DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
         })));
 
         test!(continuation_2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Ok(Line::Continuation(ZoneInfo {
             utc_offset:  TimeSpec::HoursMinutes(1, 00),
             saving:      Saving::Multiple("C-Eur"),
             format:      "CE%sT",
-            time:        Some(ZoneTime::UntilDay(YearSpec::Number(1943), MonthSpec(Month::October), DaySpec::Ordinal(25))),
+            time:        Some(ChangeTime::UntilDay(YearSpec::Number(1943), MonthSpec(Month::October), DaySpec::Ordinal(25))),
         })));
 
         test!(zone_hyphen: "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919" => Ok(Line::Zone(Zone {
@@ -813,7 +834,7 @@ mod test {
                 utc_offset:  TimeSpec::HoursMinutesSeconds(9, 32, 54),
                 saving:      Saving::NoSaving,
                 format:      "LMT",
-                time:        Some(ZoneTime::UntilYear(YearSpec::Number(1919))),
+                time:        Some(ChangeTime::UntilYear(YearSpec::Number(1919))),
             },
         })));
     }
diff --git a/src/structure.rs b/src/structure.rs
index 23d4021..65f0abd 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -1,34 +1,34 @@
-/// Determining the structure of a set of ruleset names.
-///
-/// The names of time zones in the zoneinfo database are of the form
-/// `Area/Location`, or more rarely, `Area/Location/Sublocation`. This means
-/// they form a hierarchy, with each level either serving as a time zone
-/// itself (usually a location) or as a parent of multiple other entries
-/// (usually an area).
-///
-/// When generating Rust code containing the timezone data, we need to
-/// generate the entire tree structure, not just the leaves of actual timezone
-/// data. This module determines that structure, allowing it to be created
-/// before any actual timezone data is written.
-///
-/// For example, say we have the following subset of time zone entries:
-///
-/// - America/Antigua
-/// - America/Araguaina
-/// - America/Argentina/Buenos_Aires
-/// - America/Argentina/Catamarca
-/// - America/Argentina/Cordoba
-/// - America/Aruba
-///
-/// On top of the six actual time zone files, we would need to create the following:
-///
-/// - An America module that has three private submodules (Antigua, Araguaína,
-///   and Aruba) and one public submodule (Argentina);
-/// - An America/Argentina submodule that has there private submodules (Buenos
-///   Aires, Catamarca, Cordoba).
-///
-/// This module contains an iterator that finds all parent zonesets, and
-/// sorts them so they're output in a correct order.
+//! Determining the structure of a set of ruleset names.
+//!
+//! The names of time zones in the zoneinfo database are of the form
+//! `Area/Location`, or more rarely, `Area/Location/Sublocation`. This means
+//! they form a hierarchy, with each level either serving as a time zone
+//! itself (usually a location) or as a parent of multiple other entries
+//! (usually an area).
+//!
+//! When generating Rust code containing the timezone data, we need to
+//! generate the entire tree structure, not just the leaves of actual timezone
+//! data. This module determines that structure, allowing it to be created
+//! before any actual timezone data is written.
+//!
+//! For example, say we have the following subset of time zone entries:
+//!
+//! - America/Antigua
+//! - America/Araguaina
+//! - America/Argentina/Buenos_Aires
+//! - America/Argentina/Catamarca
+//! - America/Argentina/Cordoba
+//! - America/Aruba
+//!
+//! On top of the six actual time zone files, we would need to create the following:
+//!
+//! - An America module that has three private submodules (Antigua, Araguaína,
+//!   and Aruba) and one public submodule (Argentina);
+//! - An America/Argentina submodule that has there private submodules (Buenos
+//!   Aires, Catamarca, Cordoba).
+//!
+//! This module contains an iterator that finds all parent zonesets, and
+//! sorts them so they’re output in a correct order.
 
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -60,7 +60,7 @@ impl Structure for Table {
             let parent = &key[.. last_slash];
             {
                 let set = mappings.entry(parent).or_insert_with(BTreeSet::new);
-                set.insert(Child::Ruleset(&key[last_slash + 1 ..]));
+                set.insert(Child::TimeZone(&key[last_slash + 1 ..]));
             }
 
             // If the *parent* name still has a slash in it, then this is
@@ -91,9 +91,9 @@ impl<'table> IntoIterator for TableStructure<'table> {
 
     fn into_iter(self) -> Self::IntoIter {
 
-        // It's necessary to sort the keys before producing them, to
-        // ensure that (for example) America is produced before
-        // America/Kentucky.
+        // It’s necessary to sort the keys before producing them, to
+        // ensure that (for example) `America` is produced before
+        // `America/Kentucky`.
         let mut keys: Vec<_> = self.mappings.keys().cloned().collect();
         keys.sort_by(|a, b| b.cmp(a));
 
@@ -138,17 +138,26 @@ impl<'table> Iterator for Iter<'table> {
 #[derive(PartialEq, Debug)]
 pub struct TableStructureEntry<'table> {
 
-    /// This entry's name, which **can** still include slashes.
+    /// This entry’s name, which *can* still include slashes.
     pub name: &'table str,
 
     /// A vector of sorted child names, which should have no slashes in.
     pub children: Vec<Child<'table>>,
 }
 
+/// A child module that needs to be created.
+///
+/// The order here is important for `PartialOrd`: submodules need to be
+/// created before actual time zones, as directories need to be created
+/// before the files in them can be written.
 #[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Copy, Clone)]
 pub enum Child<'table> {
+
+    /// A module containing **only** submodules, no time zones.
     Submodule(&'table str),
-    Ruleset(&'table str),
+
+    /// A module containing **only** the details of a time zone.
+    TimeZone(&'table str),
 }
 
 
@@ -182,7 +191,7 @@ mod test {
         table.zonesets.insert("a/b".to_owned(), Zoneset::default());
 
         let mut structure = table.structure().into_iter();
-        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(), children: vec![ Child::Ruleset("b") ] }));
+        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(), children: vec![ Child::TimeZone("b") ] }));
         assert_eq!(structure.next(), None);
     }
 
@@ -194,8 +203,8 @@ mod test {
         table.zonesets.insert("a/e".to_owned(),   Zoneset::default());
 
         let mut structure = table.structure().into_iter();
-        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(),   children: vec![ Child::Submodule("b"), Child::Ruleset("e") ] }));
-        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a/b".to_owned(), children: vec![ Child::Ruleset("c"),   Child::Ruleset("d") ] }));
+        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(),   children: vec![ Child::Submodule("b"), Child::TimeZone("e") ] }));
+        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a/b".to_owned(), children: vec![ Child::TimeZone("c"),  Child::TimeZone("d") ] }));
         assert_eq!(structure.next(), None);
     }
 }
diff --git a/src/table.rs b/src/table.rs
index 0e62335..7cedd21 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -1,11 +1,28 @@
+//! Collecting parsed zoneinfo data lines into a set of time zone data.
+//!
+//! This module provides the `Table` struct, which is able to take parsed
+//! lines of input from the `line` module and put them together, producing a
+//! list of time zone transitions that can be written to files.
+//!
+//! It’s not as simple as it seems, because:
+//!
+//! 1. The zoneinfo data lines refer to each other through strings, such as
+//!    “link zone A to B”; lines of that form could be *parsed* successfully
+//!    but still fail to be interpreted if “B” doesn’t exist. So it has to
+//!    check every step of the way. Nothing wrong with this, it’s just a
+//!    consequence of reading data from a text file.
+//! 2. We output the list of time zones as a set of timespans and
+//!    transitions. The logic for doing this is really complicated (see
+//!    ‘zic.c’, which has the same logic, only in C).
+
 use std::collections::hash_map::{HashMap, Entry};
 
-use line::{self, YearSpec, MonthSpec, DaySpec, ZoneTime};
+use line::{self, YearSpec, MonthSpec, DaySpec, ChangeTime};
 use datetime::{LocalDateTime, LocalTime};
 use datetime::zone::TimeType;
 
 
-/// A table of all the data in one or more zoneinfo files.
+/// A **table** of all the data in one or more zoneinfo files.
 #[derive(PartialEq, Debug, Default)]
 pub struct Table {
 
@@ -22,26 +39,61 @@ pub struct Table {
 #[derive(PartialEq, Debug, Default)]
 pub struct Ruleset(pub Vec<RuleInfo>);
 
+#[derive(PartialEq, Debug, Default)]
+pub struct Zoneset(pub Vec<ZoneInfo>);
+
+
+/// A set of timespans, separated by the instances at which the timespans
+/// change over. There will always be one more timespan than transitions.
+///
+/// This mimics the `FixedTimespanSet` struct in `datetime::cal::zone`,
+/// except it uses owned `Vec`s instead of slices.
 #[derive(PartialEq, Debug, Clone)]
 pub struct FixedTimespanSet {
+
+    /// The first timespan, which is assumed to have been in effect up until
+    /// the initial transition instant (if any). Each set has to have at
+    /// least one timespan.
     pub first: FixedTimespan,
+
+    /// The rest of the timespans, as a vector of tuples, each containing:
+    ///
+    /// 1. A transition instant at which the previous timespan ends and the
+    ///    next one begins, stored as a Unix timestamp;
+    /// 2. The actual timespan to transition into.
     pub rest: Vec<(i64, FixedTimespan)>,
 }
 
+
+/// An individual timespan with a fixed offset.
+///
+/// This mimics the `FixedTimespan` struct in `datetime::cal::zone`, except
+/// instead of “total offset” and “is DST” fields, it has separate UTC and
+/// DST fields. Also, the name is an owned `String` here instead of a slice.
 #[derive(PartialEq, Debug, Clone)]
 pub struct FixedTimespan {
+
+    /// The number of seconds offset from UTC during this timespan.
     pub utc_offset: i64,
+
+    /// The number of *extra* daylight-saving seconds during this timespan.
     pub dst_offset: i64,
-    pub name:       String,
+
+    /// The abbreviation in use during this timespan.
+    pub name: String,
 }
 
 impl FixedTimespan {
+
+    /// The total offset in effect during this timespan.
     pub fn total_offset(&self) -> i64 {
         self.utc_offset + self.dst_offset
     }
 }
 
 impl Table {
+
+    /// Compute a fixed timespan set for the timezone with the given name.
     pub fn timespans(&self, zone_name: &str) -> FixedTimespanSet {
         let mut transitions = Vec::new();
         let mut start_time = None;
@@ -260,7 +312,7 @@ pub struct RuleInfo {
     /// The amount of time to save.
     time_to_add: i64,
 
-    /// Any extra letters that should be added to this time zone's
+    /// Any extra letters that should be added to this time zone’s
     /// abbreviation, in place of `%s`.
     letters: Option<String>,
 }
@@ -307,29 +359,12 @@ impl RuleInfo {
     }
 }
 
-#[derive(PartialEq, Debug, Default)]
-pub struct Zoneset(pub Vec<ZoneInfo>);
-
 #[derive(PartialEq, Debug)]
 pub struct ZoneInfo {
     pub offset:    i64,
     pub format:    Format,
     pub saving:    Saving,
-    pub end_time:  Option<ZoneTime>,
-}
-
-#[derive(PartialEq, Debug)]
-pub enum Saving {
-    NoSaving,
-    OneOff(i64),
-    Multiple(String),
-}
-
-#[derive(PartialEq, Debug, Clone)]
-pub enum Format {
-    Constant(String),
-    Alternate { standard: String, dst: String },
-    Placeholder(String),
+    pub end_time:  Option<ChangeTime>,
 }
 
 impl<'_> From<line::ZoneInfo<'_>> for ZoneInfo {
@@ -347,7 +382,52 @@ impl<'_> From<line::ZoneInfo<'_>> for ZoneInfo {
     }
 }
 
+
+/// The amount of daylight saving time (DST) to apply to this timespan. This
+/// is a special type for a certain field in a zone line, which can hold
+/// different types of value.
+///
+/// This is the owned version of the `Saving` type in the `line` module.
+#[derive(PartialEq, Debug)]
+pub enum Saving {
+
+    /// Just stick to the base offset.
+    NoSaving,
+
+    /// This amount of time should be saved while this timespan is in effect.
+    /// (This is the equivalent to there being a single one-off rule with the
+    /// given amount of time to save).
+    OneOff(i64),
+
+    /// All rules with the given name should apply while this timespan is in
+    /// effect.
+    Multiple(String),
+}
+
+
+/// The format string to generate a time zone abbreviation from.
+#[derive(PartialEq, Debug, Clone)]
+pub enum Format {
+
+    /// A constant format, which remains the same throughout both standard
+    /// and DST timespans.
+    Constant(String),
+
+    /// An alternate format, such as “PST/PDT”, which changes between
+    /// standard and DST timespans (the first option is standard, the second
+    /// is DST).
+    Alternate { standard: String, dst: String },
+
+    /// A format with a placeholder `%s`, which uses the `letters` field in
+    /// a `RuleInfo` to generate the time zone abbreviation.
+    Placeholder(String),
+}
+
 impl Format {
+
+    /// Convert the template into one of the `Format` variants. This can’t
+    /// fail, as any syntax that doesn’t match one of the two formats will
+    /// just be a ‘constant’ format.
     fn new(template: &str) -> Format {
         if let Some(pos) = template.find('/') {
             Format::Alternate {
@@ -392,7 +472,7 @@ impl Format {
 #[derive(PartialEq, Debug)]
 pub struct TableBuilder {
 
-    /// The table that's being built up.
+    /// The table that’s being built up.
     table: Table,
 
     /// If the last line was a zone definition, then this holds its name.
@@ -413,8 +493,8 @@ impl TableBuilder {
 
     /// Adds a new line describing a zone definition.
     ///
-    /// Returns an error if there's already a zone with the same name, or the
-    /// zone refers to a ruleset that hasn't been defined yet.
+    /// Returns an error if there’s already a zone with the same name, or the
+    /// zone refers to a ruleset that hasn’t been defined yet.
     pub fn add_zone_line<'line>(&mut self, zone_line: line::Zone<'line>) -> Result<(), Error<'line>> {
         if let line::Saving::Multiple(ruleset_name) = zone_line.info.saving {
             if !self.table.rulesets.contains_key(ruleset_name) {
@@ -434,8 +514,8 @@ impl TableBuilder {
 
     /// Adds a new line describing the *continuation* of a zone definition.
     ///
-    /// Returns an error if the builder wasn't expecting a continuation line
-    /// (meaning, the previous line wasn't a zone line)
+    /// Returns an error if the builder wasn’t expecting a continuation line
+    /// (meaning, the previous line wasn’t a zone line)
     pub fn add_continuation_line(&mut self, continuation_line: line::ZoneInfo) -> Result<(), Error> {
         let mut zoneset = match self.current_zoneset_name {
             Some(ref name) => self.table.zonesets.get_mut(name).unwrap(),
@@ -447,7 +527,7 @@ impl TableBuilder {
     }
 
     /// Adds a new line describing one entry in a ruleset, creating that set
-    /// if it didn't exist already.
+    /// if it didn’t exist already.
     pub fn add_rule_line(&mut self, rule_line: line::Rule) -> Result<(), Error> {
         let ruleset = self.table.rulesets
                                 .entry(rule_line.name.to_owned())
@@ -472,7 +552,7 @@ impl TableBuilder {
         }
     }
 
-    /// Returns the table after it's finished being built.
+    /// Returns the table after it’s finished being built.
     pub fn build(self) -> Table {
         self.table
     }
@@ -482,17 +562,17 @@ impl TableBuilder {
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub enum Error<'line> {
 
-    /// A continuation line was passed in, but the previous line wasn't a zone
+    /// A continuation line was passed in, but the previous line wasn’t a zone
     /// definition line.
     SurpriseContinuationLine,
 
-    /// A zone definition referred to a ruleset that hadn't been defined.
+    /// A zone definition referred to a ruleset that hadn’t been defined.
     UnknownRuleset(&'line str),
 
-    /// A link line was passed in, but there's already a link with that name.
+    /// A link line was passed in, but there’s already a link with that name.
     DuplicateLink(&'line str),
 
-    /// A zone line was passed in, but there's already a zone with that name.
+    /// A zone line was passed in, but there’s already a zone with that name.
     DuplicateZone,
 }
 
@@ -500,9 +580,9 @@ pub enum Error<'line> {
 #[cfg(test)]
 mod test {
 
-    // Allow unused results in test code, because the only 'results' that
+    // Allow unused results in test code, because the only ‘results’ that
     // we need to ignore are the ones from inserting and removing from
-    // tables and vectors. And as we set them up ourselves, they're bound
+    // tables and vectors. And as we set them up ourselves, they’re bound
     // to be correct, otherwise the tests would fail!
     #![allow(unused_results)]
 
@@ -515,7 +595,7 @@ mod test {
     use line::MonthSpec;
     use line::YearSpec;
     use line::TimeSpec;
-    use line::ZoneTime;
+    use line::ChangeTime;
 
     #[test]
     fn no_transitions() {
@@ -541,7 +621,7 @@ mod test {
             offset: 1234,
             format: Format::new("TEST"),
             saving: Saving::NoSaving,
-            end_time: Some(ZoneTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(2), TimeSpec::HoursMinutesSeconds(10, 17, 36).with_type(TimeType::UTC))),
+            end_time: Some(ChangeTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(2), TimeSpec::HoursMinutesSeconds(10, 17, 36).with_type(TimeType::UTC))),
         };
 
         let zone_2 = ZoneInfo {
@@ -571,14 +651,14 @@ mod test {
             offset: 1234,
             format: Format::new("TEST"),
             saving: Saving::NoSaving,
-            end_time: Some(ZoneTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(2), TimeSpec::HoursMinutesSeconds(10, 17, 36).with_type(TimeType::Standard))),
+            end_time: Some(ChangeTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(2), TimeSpec::HoursMinutesSeconds(10, 17, 36).with_type(TimeType::Standard))),
         };
 
         let zone_2 = ZoneInfo {
             offset: 3456,
             format: Format::new("TSET"),
             saving: Saving::NoSaving,
-            end_time: Some(ZoneTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(3), TimeSpec::HoursMinutesSeconds(17, 09, 27).with_type(TimeType::Standard))),
+            end_time: Some(ChangeTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(3), TimeSpec::HoursMinutesSeconds(17, 09, 27).with_type(TimeType::Standard))),
         };
 
         let zone_3 = ZoneInfo {
@@ -629,7 +709,7 @@ mod test {
             offset: 0,
             format: Format::new("LMT"),
             saving: Saving::NoSaving,
-            end_time: Some(ZoneTime::UntilYear(YearSpec::Number(1980))),
+            end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1980))),
         };
 
         let zone = ZoneInfo {
@@ -680,7 +760,7 @@ mod test {
             offset: 0,
             format: Format::new("LMT"),
             saving: Saving::NoSaving,
-            end_time: Some(ZoneTime::UntilYear(YearSpec::Number(1980))),
+            end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1980))),
         };
 
         let zone = ZoneInfo {
@@ -726,14 +806,14 @@ mod test {
         ]);
 
         let zone = vec![
-            ZoneInfo { offset: 3164, format: Format::new("LMT"),   saving: Saving::NoSaving,                     end_time: Some(ZoneTime::UntilYear(YearSpec::Number(1920))) },
-            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ZoneTime::UntilYear(YearSpec::Number(1959)))  },
-            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ZoneTime::UntilYear(YearSpec::Number(1982)))   },
-            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ZoneTime::UntilDay (YearSpec::Number(1990), MonthSpec(May),       DaySpec::Ordinal( 4)))   },
-            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ZoneTime::UntilDay (YearSpec::Number(1996), MonthSpec(September), DaySpec::Ordinal(30)))   },
-            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ZoneTime::UntilDay (YearSpec::Number(1997), MonthSpec(October),   DaySpec::Ordinal( 4)))   },
-            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ZoneTime::UntilTime(YearSpec::Number(2012), MonthSpec(November),  DaySpec::Ordinal(10), TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall)))  },
-            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ZoneTime::UntilTime(YearSpec::Number(2013), MonthSpec(October),   DaySpec::Ordinal(25), TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall)))  },
+            ZoneInfo { offset: 3164, format: Format::new("LMT"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1920))) },
+            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1959)))  },
+            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1982)))   },
+            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilDay (YearSpec::Number(1990), MonthSpec(May),       DaySpec::Ordinal( 4)))   },
+            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilDay (YearSpec::Number(1996), MonthSpec(September), DaySpec::Ordinal(30)))   },
+            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilDay (YearSpec::Number(1997), MonthSpec(October),   DaySpec::Ordinal( 4)))   },
+            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilTime(YearSpec::Number(2012), MonthSpec(November),  DaySpec::Ordinal(10), TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall)))  },
+            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilTime(YearSpec::Number(2013), MonthSpec(October),   DaySpec::Ordinal(25), TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall)))  },
             ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: None              },
         ];
 

From 0fe5a619f771a1cd279ec84b02a533858b93bbd4 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 13 Nov 2015 15:15:50 +0000
Subject: [PATCH 032/113] Inline the Ruleset and Zoneset structs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Although I’d usually be for encapsulating behaviour like this, there’s a lot of surrounding code in this module, and they just kind of get lost in the noise. Plus, this makes the structure of the Table type a bit more clear.
---
 src/structure.rs | 16 +++++++--------
 src/table.rs     | 53 ++++++++++++++++++++++--------------------------
 2 files changed, 32 insertions(+), 37 deletions(-)

diff --git a/src/structure.rs b/src/structure.rs
index 65f0abd..5e1d744 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -165,7 +165,7 @@ pub enum Child<'table> {
 #[allow(unused_results)]
 mod test {
     use super::*;
-    use table::{Table, Zoneset};
+    use table::Table;
 
     #[test]
     fn empty() {
@@ -177,9 +177,9 @@ mod test {
     #[test]
     fn separate() {
         let mut table = Table::default();
-        table.zonesets.insert("a".to_owned(), Zoneset::default());
-        table.zonesets.insert("b".to_owned(), Zoneset::default());
-        table.zonesets.insert("c".to_owned(), Zoneset::default());
+        table.zonesets.insert("a".to_owned(), Vec::new());
+        table.zonesets.insert("b".to_owned(), Vec::new());
+        table.zonesets.insert("c".to_owned(), Vec::new());
 
         let mut structure = table.structure().into_iter();
         assert_eq!(structure.next(), None);
@@ -188,7 +188,7 @@ mod test {
     #[test]
     fn child() {
         let mut table = Table::default();
-        table.zonesets.insert("a/b".to_owned(), Zoneset::default());
+        table.zonesets.insert("a/b".to_owned(), Vec::new());
 
         let mut structure = table.structure().into_iter();
         assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(), children: vec![ Child::TimeZone("b") ] }));
@@ -198,9 +198,9 @@ mod test {
     #[test]
     fn hierarchy() {
         let mut table = Table::default();
-        table.zonesets.insert("a/b/c".to_owned(), Zoneset::default());
-        table.zonesets.insert("a/b/d".to_owned(), Zoneset::default());
-        table.zonesets.insert("a/e".to_owned(),   Zoneset::default());
+        table.zonesets.insert("a/b/c".to_owned(), Vec::new());
+        table.zonesets.insert("a/b/d".to_owned(), Vec::new());
+        table.zonesets.insert("a/e".to_owned(),   Vec::new());
 
         let mut structure = table.structure().into_iter();
         assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(),   children: vec![ Child::Submodule("b"), Child::TimeZone("e") ] }));
diff --git a/src/table.rs b/src/table.rs
index 7cedd21..1e4dd87 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -27,21 +27,15 @@ use datetime::zone::TimeType;
 pub struct Table {
 
     /// Mapping of ruleset names to rulesets.
-    pub rulesets: HashMap<String, Ruleset>,
+    pub rulesets: HashMap<String, Vec<RuleInfo>>,
 
     /// Mapping of zoneset names to zonesets.
-    pub zonesets: HashMap<String, Zoneset>,
+    pub zonesets: HashMap<String, Vec<ZoneInfo>>,
 
     /// Mapping of link timezone names, to the names they link to.
     pub links: HashMap<String, String>,
 }
 
-#[derive(PartialEq, Debug, Default)]
-pub struct Ruleset(pub Vec<RuleInfo>);
-
-#[derive(PartialEq, Debug, Default)]
-pub struct Zoneset(pub Vec<ZoneInfo>);
-
 
 /// A set of timespans, separated by the instances at which the timespans
 /// change over. There will always be one more timespan than transitions.
@@ -91,6 +85,7 @@ impl FixedTimespan {
     }
 }
 
+
 impl Table {
 
     /// Compute a fixed timespan set for the timezone with the given name.
@@ -102,9 +97,9 @@ impl Table {
         let mut first_transition = None;
 
         let timespans = &self.zonesets[zone_name];
-        for (i, timespan) in timespans.0.iter().enumerate() {
+        for (i, timespan) in timespans.iter().enumerate() {
             let mut dst_offset = 0;
-            let use_until      = i != timespans.0.len() - 1;
+            let use_until      = i != timespans.len() - 1;
             let utc_offset     = timespan.offset;
 
             let mut insert_start_transition = i > 0;
@@ -165,7 +160,7 @@ impl Table {
                             break;
                         }
 
-                        let mut activated_rules = self.rulesets[&*rules].0.iter()
+                        let mut activated_rules = self.rulesets[&*rules].iter()
                                                       .filter(|r| r.applies_to_year(year))
                                                       .collect::<Vec<_>>();
 
@@ -504,10 +499,10 @@ impl TableBuilder {
 
         let mut zoneset = match self.table.zonesets.entry(zone_line.name.to_owned()) {
             Entry::Occupied(_)  => return Err(Error::DuplicateZone),
-            Entry::Vacant(e)    => e.insert(Zoneset(Vec::new())),
+            Entry::Vacant(e)    => e.insert(Vec::new()),
         };
 
-        let _ = zoneset.0.push(zone_line.info.into());
+        let _ = zoneset.push(zone_line.info.into());
         self.current_zoneset_name = Some(zone_line.name.to_owned());
         Ok(())
     }
@@ -522,7 +517,7 @@ impl TableBuilder {
             None => return Err(Error::SurpriseContinuationLine),
         };
 
-        let _ = zoneset.0.push(continuation_line.into());
+        let _ = zoneset.push(continuation_line.into());
         Ok(())
     }
 
@@ -531,9 +526,9 @@ impl TableBuilder {
     pub fn add_rule_line(&mut self, rule_line: line::Rule) -> Result<(), Error> {
         let ruleset = self.table.rulesets
                                 .entry(rule_line.name.to_owned())
-                                .or_insert_with(|| Ruleset(Vec::new()));
+                                .or_insert_with(|| Vec::new());
 
-        ruleset.0.push(rule_line.into());
+        ruleset.push(rule_line.into());
         self.current_zoneset_name = None;
         Ok(())
     }
@@ -586,7 +581,7 @@ mod test {
     // to be correct, otherwise the tests would fail!
     #![allow(unused_results)]
 
-    use super::{FixedTimespan, FixedTimespanSet, Saving, ZoneInfo, RuleInfo, Ruleset, Table, Zoneset, Format, optimise};
+    use super::{FixedTimespan, FixedTimespanSet, Saving, ZoneInfo, RuleInfo, Table, Format, optimise};
     use datetime::Weekday::*;
     use datetime::Month::*;
     use datetime::zone::TimeType;
@@ -607,7 +602,7 @@ mod test {
         };
 
         let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone ]));
+        table.zonesets.insert("Test/Zone".to_owned(), vec![ zone ]);
 
         assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
             first: FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned() },
@@ -632,7 +627,7 @@ mod test {
         };
 
         let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone_1, zone_2 ]));
+        table.zonesets.insert("Test/Zone".to_owned(), vec![ zone_1, zone_2 ]);
 
         let expected = FixedTimespanSet {
             first:       FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned() },
@@ -669,7 +664,7 @@ mod test {
         };
 
         let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ zone_1, zone_2, zone_3 ]));
+        table.zonesets.insert("Test/Zone".to_owned(), vec![ zone_1, zone_2, zone_3 ]);
 
         let expected = FixedTimespanSet {
             first: FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned(), },
@@ -692,7 +687,7 @@ mod test {
 
     #[test]
     fn one_rule() {
-        let ruleset = Ruleset(vec![
+        let ruleset = vec![
             RuleInfo {
                 from_year:   YearSpec::Number(1980),
                 to_year:     None,
@@ -703,7 +698,7 @@ mod test {
                 time_to_add: 1000,
                 letters:     None,
             }
-        ]);
+        ];
 
         let lmt = ZoneInfo {
             offset: 0,
@@ -720,7 +715,7 @@ mod test {
         };
 
         let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ lmt, zone ]));
+        table.zonesets.insert("Test/Zone".to_owned(), vec![ lmt, zone ]);
         table.rulesets.insert("Dwayne".to_owned(), ruleset);
 
         assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
@@ -733,7 +728,7 @@ mod test {
 
     #[test]
     fn two_rules() {
-        let ruleset = Ruleset(vec![
+        let ruleset = vec![
             RuleInfo {
                 from_year:   YearSpec::Number(1980),
                 to_year:     None,
@@ -754,7 +749,7 @@ mod test {
                 time_to_add: 1500,
                 letters:     None,
             },
-        ]);
+        ];
 
         let lmt = ZoneInfo {
             offset: 0,
@@ -771,7 +766,7 @@ mod test {
         };
 
         let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(vec![ lmt, zone ]));
+        table.zonesets.insert("Test/Zone".to_owned(), vec![ lmt, zone ]);
         table.rulesets.insert("Dwayne".to_owned(), ruleset);
 
         assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
@@ -785,7 +780,7 @@ mod test {
 
     #[test]
     fn tripoli() {
-        let libya = Ruleset(vec![
+        let libya = vec![
             RuleInfo { from_year: YearSpec::Number(1951), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(14),               time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
             RuleInfo { from_year: YearSpec::Number(1952), to_year: None,                         month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
             RuleInfo { from_year: YearSpec::Number(1953), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(9),                time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
@@ -803,7 +798,7 @@ mod test {
             RuleInfo { from_year: YearSpec::Number(1997), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
             RuleInfo { from_year: YearSpec::Number(2013), to_year: None,                         month: MonthSpec(March),     day: DaySpec::Last(WeekdaySpec(Friday)), time: 3600, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
             RuleInfo { from_year: YearSpec::Number(2013), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Last(WeekdaySpec(Friday)), time: 7200, time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-        ]);
+        ];
 
         let zone = vec![
             ZoneInfo { offset: 3164, format: Format::new("LMT"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1920))) },
@@ -818,7 +813,7 @@ mod test {
         ];
 
         let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), Zoneset(zone));
+        table.zonesets.insert("Test/Zone".to_owned(), zone);
         table.rulesets.insert("Libya".to_owned(), libya);
 
         assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {

From d06474a29760355ada4521a6fca71deed09052ee Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 13 Nov 2015 19:29:57 +0000
Subject: [PATCH 033/113] Include linked timezones in the data
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The timezone data crate now contains *all* the timezones, rather than just the ones listed in the zoneinfo files.

This completes the timezone data. All that’s left to do is the geolocation stuff.
---
 bin/build-data-crate.rs |  6 +++---
 src/structure.rs        |  2 +-
 src/table.rs            | 23 +++++++++++++++++++----
 3 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 10311b4..4cb416f 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -61,7 +61,7 @@ impl DataCrate {
 
                 let result = match Line::from_str(line_portion) {
 
-                    // If there's an error, then display which line failed to parse.
+                    // If there’s an error, then display which line failed to parse.
                     Err(_) => {
                         println!("Failed to parse line: {:?}", line_portion);
                         errors += 1;
@@ -136,7 +136,7 @@ impl DataCrate {
             }
         }
 
-        let mut keys: Vec<_> = self.table.zonesets.keys().collect();
+        let mut keys: Vec<_> = self.table.zonesets.keys().chain(self.table.links.keys()).collect();
         keys.sort();
 
         try!(writeln!(base_w, "\n\n"));
@@ -160,7 +160,7 @@ impl DataCrate {
     }
 
     fn write_zonesets(&self) -> IoResult<()> {
-        for name in self.table.zonesets.keys() {
+        for name in self.table.zonesets.keys().chain(self.table.links.keys()) {
             let components: PathBuf = name.split('/').map(sanitise_name).collect();
             let zoneset_path = self.base_path.join(components).with_extension("rs");
             let mut w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(zoneset_path));
diff --git a/src/structure.rs b/src/structure.rs
index 5e1d744..e08f1eb 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -46,7 +46,7 @@ impl Structure for Table {
     fn structure(&self) -> TableStructure {
         let mut mappings = BTreeMap::new();
 
-        for key in self.zonesets.keys() {
+        for key in self.zonesets.keys().chain(self.links.keys()) {
 
             // Extract the name from the *last* slash. So
             // `America/Kentucky/Louisville` is split into
diff --git a/src/table.rs b/src/table.rs
index 1e4dd87..9ab61ad 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -88,7 +88,22 @@ impl FixedTimespan {
 
 impl Table {
 
-    /// Compute a fixed timespan set for the timezone with the given name.
+    /// Tries to find the zoneset with the given name by looking it up in
+    /// either the zonesets map or the links map.
+    pub fn get_zoneset(&self, zone_name: &str) -> &[ZoneInfo] {
+        if self.zonesets.contains_key(zone_name) {
+            &*self.zonesets[zone_name]
+        }
+        else if self.links.contains_key(zone_name) {
+            let target = &self.links[zone_name];
+            &*self.zonesets[&*target]
+        }
+        else {
+            panic!("No such zone: {:?}", zone_name);
+        }
+    }
+
+    /// Computes a fixed timespan set for the timezone with the given name.
     pub fn timespans(&self, zone_name: &str) -> FixedTimespanSet {
         let mut transitions = Vec::new();
         let mut start_time = None;
@@ -96,10 +111,10 @@ impl Table {
 
         let mut first_transition = None;
 
-        let timespans = &self.zonesets[zone_name];
-        for (i, timespan) in timespans.iter().enumerate() {
+        let zoneset = self.get_zoneset(zone_name);
+        for (i, timespan) in zoneset.iter().enumerate() {
             let mut dst_offset = 0;
-            let use_until      = i != timespans.len() - 1;
+            let use_until      = i != zoneset.len() - 1;
             let utc_offset     = timespan.offset;
 
             let mut insert_start_transition = i > 0;

From 9ed0678cfcbbbd594903ecebdabae880b816f718 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Tue, 17 Nov 2015 14:51:48 +0000
Subject: [PATCH 034/113] Use new date iterators

See datetime@edb41e214d784cb59dca683029fe3867ebe11d50 for the change that broke the old code.
---
 src/line.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index fb65ee0..10aeac6 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -526,9 +526,9 @@ impl DaySpec {
 
         match *self {
             DaySpec::Ordinal(day)           => LocalDate::ymd(year, month, day).unwrap(),
-            DaySpec::Last(w)                => DaySpec::find_weekday(w, Year(year).days_for_month(month).rev()),
-            DaySpec::LastOnOrBefore(w, day) => DaySpec::find_weekday(w, Year(year).days_for_month(month).rev().filter(|d| d.day() < day)),
-            DaySpec::FirstOnOrAfter(w, day) => DaySpec::find_weekday(w, Year(year).days_for_month(month).skip(day as usize - 1)),
+            DaySpec::Last(w)                => DaySpec::find_weekday(w, Year(year).month(month).days(..).rev()),
+            DaySpec::LastOnOrBefore(w, day) => DaySpec::find_weekday(w, Year(year).month(month).days(..).rev().filter(|d| d.day() < day)),
+            DaySpec::FirstOnOrAfter(w, day) => DaySpec::find_weekday(w, Year(year).month(month).days(..).skip(day as usize - 1)),
         }
     }
 

From 34c9883baad9b7f725523f245518850661a575e2 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Wed, 18 Nov 2015 17:34:52 +0000
Subject: [PATCH 035/113] Rename TimeZone -> StaticTimeZone

Commit datetime@e6012ba003a8f5949510dea0f9ff334234202b07 caused this. All the time zones we want to build are static (available throughout the program).
---
 bin/build-data-crate.rs | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 4cb416f..e108c1b 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -147,10 +147,10 @@ impl DataCrate {
         }
 
         try!(writeln!(base_w, "\n\n"));
-        try!(writeln!(base_w, "pub fn lookup(input: &str) -> Option<TimeZone<'static>> {{"));
+        try!(writeln!(base_w, "pub fn lookup(input: &str) -> Option<&'static StaticTimeZone<'static>> {{"));
         for name in &keys {
             try!(writeln!(base_w, "    if input == {:?} {{", name));
-            try!(writeln!(base_w, "        return Some({});", sanitise_name(name).replace("/", "::")));
+            try!(writeln!(base_w, "        return Some(&{});", sanitise_name(name).replace("/", "::")));
             try!(writeln!(base_w, "    }}"));
         }
         try!(writeln!(base_w, "    return None;"));
@@ -167,7 +167,7 @@ impl DataCrate {
             try!(writeln!(w, "{}", WARNING_HEADER));
             try!(writeln!(w, "{}", ZONEINFO_HEADER));
 
-            try!(writeln!(w, "pub const ZONE: TimeZone<'static> = TimeZone {{"));
+            try!(writeln!(w, "pub static ZONE: StaticTimeZone<'static> = StaticTimeZone {{"));
             try!(writeln!(w, "    name: {:?},", name));
             try!(writeln!(w, "    fixed_timespans: FixedTimespanSet {{"));
 
@@ -176,7 +176,7 @@ impl DataCrate {
             try!(writeln!(w, "        first: FixedTimespan {{"));
             try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", set.first.total_offset(), set.first.utc_offset, set.first.dst_offset));
             try!(writeln!(w, "            is_dst: {:?},", set.first.dst_offset != 0));
-            try!(writeln!(w, "            name:   {:?},", set.first.name));
+            try!(writeln!(w, "            name:   Cow::Borrowed({:?}),", set.first.name));
             try!(writeln!(w, "        }},"));
 
             try!(writeln!(w, "        rest: &["));
@@ -189,7 +189,7 @@ impl DataCrate {
                 // comment in the data crate.
                 try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", t.1.total_offset(), t.1.utc_offset, t.1.dst_offset));
                 try!(writeln!(w, "            is_dst: {:?},", t.1.dst_offset != 0));
-                try!(writeln!(w, "            name:   {:?},", t.1.name));
+                try!(writeln!(w, "            name:   Cow::Borrowed({:?}),", t.1.name));
                 try!(writeln!(w, "        }}),"));
             }
             try!(writeln!(w, "    ]}},"));
@@ -219,9 +219,10 @@ const WARNING_HEADER: &'static str = r##"
 "##;
 
 const ZONEINFO_HEADER: &'static str = r##"
-use datetime::zone::{TimeZone, FixedTimespanSet, FixedTimespan};
+use std::borrow::Cow;
+use datetime::zone::{StaticTimeZone, FixedTimespanSet, FixedTimespan};
 "##;
 
 const MOD_HEADER: &'static str = r##"
-use datetime::zone::TimeZone;
+use datetime::zone::StaticTimeZone;
 "##;

From 54c72637f547237f8254216e469976d1f62768e9 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Tue, 24 Nov 2015 17:05:45 +0000
Subject: [PATCH 036/113] Misc clippy improvements

- to_string -> to_owned
- Eliminate redundant closures and bindings
- More easily clone a vector
---
 src/structure.rs |  4 +---
 src/table.rs     | 14 +++++++-------
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/structure.rs b/src/structure.rs
index e08f1eb..d0fc6aa 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -122,9 +122,7 @@ impl<'table> Iterator for Iter<'table> {
             };
 
             // Move the strings out into an (automatically-sorted) vector.
-            let values = self.structure.mappings[key].iter()
-                                                     .map(|&s| s)
-                                                     .collect();
+            let values = self.structure.mappings[key].iter().cloned().collect();
 
             return Some(TableStructureEntry {
                 name: key,
diff --git a/src/table.rs b/src/table.rs
index 9ab61ad..89208d1 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -131,7 +131,7 @@ impl Table {
                         let t = (start_time.unwrap(), FixedTimespan {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_string()),
+                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
                         });
                         transitions.push(t);
                         insert_start_transition = false;
@@ -140,7 +140,7 @@ impl Table {
                         first_transition = Some(FixedTimespan {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_string()),
+                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
                         });
                     }
                 },
@@ -153,7 +153,7 @@ impl Table {
                         let t = (start_time.unwrap(), FixedTimespan {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_string()),
+                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
                         });
                         transitions.push(t);
                         insert_start_transition = false;
@@ -162,7 +162,7 @@ impl Table {
                         first_transition = Some(FixedTimespan {
                             utc_offset: utc_offset,
                             dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_string()),
+                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
                         });
                     }
                 },
@@ -517,7 +517,7 @@ impl TableBuilder {
             Entry::Vacant(e)    => e.insert(Vec::new()),
         };
 
-        let _ = zoneset.push(zone_line.info.into());
+        zoneset.push(zone_line.info.into());
         self.current_zoneset_name = Some(zone_line.name.to_owned());
         Ok(())
     }
@@ -532,7 +532,7 @@ impl TableBuilder {
             None => return Err(Error::SurpriseContinuationLine),
         };
 
-        let _ = zoneset.push(continuation_line.into());
+        zoneset.push(continuation_line.into());
         Ok(())
     }
 
@@ -541,7 +541,7 @@ impl TableBuilder {
     pub fn add_rule_line(&mut self, rule_line: line::Rule) -> Result<(), Error> {
         let ruleset = self.table.rulesets
                                 .entry(rule_line.name.to_owned())
-                                .or_insert_with(|| Vec::new());
+                                .or_insert_with(Vec::new);
 
         ruleset.push(rule_line.into());
         self.current_zoneset_name = None;

From 00c2ab9793208c411bc8d298a06af88bbfb3a914 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Tue, 24 Nov 2015 21:07:08 +0000
Subject: [PATCH 037/113] Impl Error for any error types

...and print them out all in one go, rather than as they occur. This is work towards making the library more error-tolerant.
---
 bin/build-data-crate.rs | 49 +++++++++++++++++++++++++++++------------
 src/line.rs             | 17 ++++++++++++++
 src/table.rs            | 18 +++++++++++++++
 3 files changed, 70 insertions(+), 14 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index e108c1b..8efa988 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -1,7 +1,8 @@
 use std::env::args;
+use std::error::Error as ErrorTrait;
 use std::io::prelude::*;
 use std::io::BufReader;
-use std::io::Result as IoResult;
+use std::io::Result as IOResult;
 use std::fs::{File, OpenOptions, create_dir, metadata};
 use std::path::{Path, PathBuf};
 use std::process::exit;
@@ -18,7 +19,11 @@ fn main() {
 
     let data_crate = match DataCrate::new(&args[0], &args[1..]) {
         Ok(dc) => dc,
-        Err(_) => {
+        Err(errs) => {
+            for err in errs {
+                println!("{}:{}: {}", err.filename, err.line, err.error);
+            }
+
             println!("Errors occurred - not going any further.");
             exit(1);
         },
@@ -40,17 +45,17 @@ struct DataCrate {
 
 impl DataCrate {
 
-    fn new<P>(base_path: P, input_file_paths: &[String]) -> Result<DataCrate, u32>
+    fn new<P>(base_path: P, input_file_paths: &[String]) -> Result<DataCrate, Vec<Error>>
     where P: Into<PathBuf> {
 
         let mut builder = TableBuilder::new();
-        let mut errors = 0;
+        let mut errors = Vec::new();
 
         for arg in input_file_paths {
             let f = File::open(arg).unwrap();
             let reader = BufReader::new(f);
 
-            for line in reader.lines() {
+            for (line_number, line) in reader.lines().enumerate() {
                 let line = line.unwrap();
 
                 // Strip out the comment portion from the line, if any.
@@ -62,9 +67,14 @@ impl DataCrate {
                 let result = match Line::from_str(line_portion) {
 
                     // If there’s an error, then display which line failed to parse.
-                    Err(_) => {
-                        println!("Failed to parse line: {:?}", line_portion);
-                        errors += 1;
+                    Err(e) => {
+                        let error = Error {
+                            filename: arg.clone(),
+                            line: line_number + 1,
+                            error: e.description().to_owned(),
+                        };
+
+                        errors.push(error);
                         continue;
                     },
 
@@ -78,13 +88,18 @@ impl DataCrate {
                 };
 
                 if let Err(e) = result {
-                    errors += 1;
-                    println!("Error: {:?}", e);
+                    let error = Error {
+                        filename: arg.clone(),
+                        line: line_number + 1,
+                        error: e.description().to_owned(),
+                    };
+
+                    errors.push(error);
                 }
             }
         }
 
-        if errors == 0 {
+        if errors.is_empty() {
             Ok(DataCrate {
                 base_path: base_path.into(),
                 table: builder.build()
@@ -95,13 +110,13 @@ impl DataCrate {
         }
     }
 
-    fn run(&self) -> IoResult<()> {
+    fn run(&self) -> IOResult<()> {
         try!(self.create_structure_directories());
         try!(self.write_zonesets());
         Ok(())
     }
 
-    fn create_structure_directories(&self) -> IoResult<()> {
+    fn create_structure_directories(&self) -> IOResult<()> {
         let base_mod_path = self.base_path.join("mod.rs");
         let mut base_w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(base_mod_path));
         try!(writeln!(base_w, "{}", WARNING_HEADER));
@@ -159,7 +174,7 @@ impl DataCrate {
         Ok(())
     }
 
-    fn write_zonesets(&self) -> IoResult<()> {
+    fn write_zonesets(&self) -> IOResult<()> {
         for name in self.table.zonesets.keys().chain(self.table.links.keys()) {
             let components: PathBuf = name.split('/').map(sanitise_name).collect();
             let zoneset_path = self.base_path.join(components).with_extension("rs");
@@ -211,6 +226,12 @@ fn sanitise_name(name: &str) -> String {
     name.replace("-", "_")
 }
 
+struct Error {
+    filename: String,
+    line: usize,
+    error: String,
+}
+
 const WARNING_HEADER: &'static str = r##"
 // ------
 // This file is autogenerated!
diff --git a/src/line.rs b/src/line.rs
index 10aeac6..1fe523e 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -9,6 +9,8 @@
 //! `table` module.
 
 use std::ascii::AsciiExt;
+use std::error::Error as ErrorTrait;
+use std::fmt;
 use std::str::FromStr;
 
 use datetime::{LocalDate, LocalTime, LocalDateTime, Month, Weekday};
@@ -693,6 +695,21 @@ pub enum Error {
     Fail
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.description())
+    }
+}
+
+impl ErrorTrait for Error {
+    fn description(&self) -> &str {
+        "parse error"
+    }
+
+    fn cause(&self) -> Option<&ErrorTrait> {
+        None
+    }
+}
 
 /// A type of valid line that has been parsed.
 #[derive(PartialEq, Debug, Copy, Clone)]
diff --git a/src/table.rs b/src/table.rs
index 89208d1..010e4df 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -16,6 +16,8 @@
 //!    ‘zic.c’, which has the same logic, only in C).
 
 use std::collections::hash_map::{HashMap, Entry};
+use std::error::Error as ErrorTrait;
+use std::fmt;
 
 use line::{self, YearSpec, MonthSpec, DaySpec, ChangeTime};
 use datetime::{LocalDateTime, LocalTime};
@@ -586,6 +588,22 @@ pub enum Error<'line> {
     DuplicateZone,
 }
 
+impl<'line> fmt::Display for Error<'line> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.description())
+    }
+}
+
+impl<'line> ErrorTrait for Error<'line> {
+    fn description(&self) -> &str {
+        "interpretation error"
+    }
+
+    fn cause(&self) -> Option<&ErrorTrait> {
+        None
+    }
+}
+
 
 #[cfg(test)]
 mod test {

From 0a0d8a5d4e4613c3b57cd40b5957c20efa3b5759 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 4 Dec 2015 01:21:53 +0000
Subject: [PATCH 038/113] extract transition-making logic to its own module

This separates the table module, which deals with table *construction*, and the transitions module, which deals with table *examination*.

Casualties include the missing_docs lint, which had to go as I had to make lots of stuff public, and a few re-exports in lib.
---
 bin/build-data-crate.rs   |   5 +-
 src/lib.rs                |  18 +-
 src/line.rs               |   4 +-
 src/table.rs              | 581 +-------------------------------------
 src/transitions.rs        | 295 +++++++++++++++++++
 tests/transition_tests.rs | 272 ++++++++++++++++++
 6 files changed, 594 insertions(+), 581 deletions(-)
 create mode 100644 src/transitions.rs
 create mode 100644 tests/transition_tests.rs

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 8efa988..507de21 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -11,7 +11,10 @@ extern crate datetime;
 use datetime::LocalDateTime;
 
 extern crate zoneinfo_parse;
-use zoneinfo_parse::{Line, TableBuilder, Table, Structure, Child};
+use zoneinfo_parse::line::{Line};
+use zoneinfo_parse::table::{Table, TableBuilder};
+use zoneinfo_parse::structure::{Structure, Child};
+use zoneinfo_parse::transitions::{TableTransitions};
 
 
 fn main() {
diff --git a/src/lib.rs b/src/lib.rs
index 368b262..124fa60 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,8 +1,12 @@
 //! Parsing Olson DB formats.
 
+#![crate_name = "zoneinfo_parse"]
+#![crate_type = "rlib"]
+#![crate_type = "dylib"]
+
 #![warn(missing_copy_implementations)]
 #![warn(missing_debug_implementations)]
-#![warn(missing_docs)]
+//#![warn(missing_docs)]
 
 #![warn(trivial_casts, trivial_numeric_casts)]
 #![warn(unused_qualifications)]
@@ -12,11 +16,7 @@ extern crate datetime;
 extern crate regex;
 #[macro_use] extern crate lazy_static;
 
-mod line;
-pub use line::Line;
-
-mod table;
-pub use table::{Table, TableBuilder, Saving, FixedTimespanSet, FixedTimespan};
-
-mod structure;
-pub use structure::*;
\ No newline at end of file
+pub mod line;
+pub mod table;
+pub mod transitions;
+pub mod structure;
diff --git a/src/line.rs b/src/line.rs
index 1fe523e..653ecc4 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -523,8 +523,7 @@ impl DaySpec {
     /// Converts this day specification to a concrete date, given the year and
     /// month it should occur in.
     pub fn to_concrete_date(&self, year: i64, month: Month) -> LocalDate {
-        use datetime::{LocalDate, DatePiece};
-        use datetime::iter::Year;
+        use datetime::{LocalDate, DatePiece, Year};
 
         match *self {
             DaySpec::Ordinal(day)           => LocalDate::ymd(year, month, day).unwrap(),
@@ -614,7 +613,6 @@ pub struct TimeSpecAndType(pub TimeSpec, pub TimeType);
 impl TimeSpec {
 
     /// Shorthand `TimeSpecAndType` constructor for testing.
-    #[cfg(test)]
     pub fn with_type(self, time_type: TimeType) -> TimeSpecAndType {
         TimeSpecAndType(self, time_type)
     }
diff --git a/src/table.rs b/src/table.rs
index 010e4df..0ae3535 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -39,55 +39,6 @@ pub struct Table {
 }
 
 
-/// A set of timespans, separated by the instances at which the timespans
-/// change over. There will always be one more timespan than transitions.
-///
-/// This mimics the `FixedTimespanSet` struct in `datetime::cal::zone`,
-/// except it uses owned `Vec`s instead of slices.
-#[derive(PartialEq, Debug, Clone)]
-pub struct FixedTimespanSet {
-
-    /// The first timespan, which is assumed to have been in effect up until
-    /// the initial transition instant (if any). Each set has to have at
-    /// least one timespan.
-    pub first: FixedTimespan,
-
-    /// The rest of the timespans, as a vector of tuples, each containing:
-    ///
-    /// 1. A transition instant at which the previous timespan ends and the
-    ///    next one begins, stored as a Unix timestamp;
-    /// 2. The actual timespan to transition into.
-    pub rest: Vec<(i64, FixedTimespan)>,
-}
-
-
-/// An individual timespan with a fixed offset.
-///
-/// This mimics the `FixedTimespan` struct in `datetime::cal::zone`, except
-/// instead of “total offset” and “is DST” fields, it has separate UTC and
-/// DST fields. Also, the name is an owned `String` here instead of a slice.
-#[derive(PartialEq, Debug, Clone)]
-pub struct FixedTimespan {
-
-    /// The number of seconds offset from UTC during this timespan.
-    pub utc_offset: i64,
-
-    /// The number of *extra* daylight-saving seconds during this timespan.
-    pub dst_offset: i64,
-
-    /// The abbreviation in use during this timespan.
-    pub name: String,
-}
-
-impl FixedTimespan {
-
-    /// The total offset in effect during this timespan.
-    pub fn total_offset(&self) -> i64 {
-        self.utc_offset + self.dst_offset
-    }
-}
-
-
 impl Table {
 
     /// Tries to find the zoneset with the given name by looking it up in
@@ -104,229 +55,37 @@ impl Table {
             panic!("No such zone: {:?}", zone_name);
         }
     }
-
-    /// Computes a fixed timespan set for the timezone with the given name.
-    pub fn timespans(&self, zone_name: &str) -> FixedTimespanSet {
-        let mut transitions = Vec::new();
-        let mut start_time = None;
-        let mut until_time = None;
-
-        let mut first_transition = None;
-
-        let zoneset = self.get_zoneset(zone_name);
-        for (i, timespan) in zoneset.iter().enumerate() {
-            let mut dst_offset = 0;
-            let use_until      = i != zoneset.len() - 1;
-            let utc_offset     = timespan.offset;
-
-            let mut insert_start_transition = i > 0;
-            let mut start_zone_id = None;
-            let mut start_utc_offset = timespan.offset;
-            let mut start_dst_offset = 0;
-
-            match timespan.saving {
-                Saving::NoSaving => {
-                    dst_offset = 0;
-                    start_zone_id = Some(timespan.format.format_constant());
-
-                    if insert_start_transition {
-                        let t = (start_time.unwrap(), FixedTimespan {
-                            utc_offset: utc_offset,
-                            dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
-                        });
-                        transitions.push(t);
-                        insert_start_transition = false;
-                    }
-                    else {
-                        first_transition = Some(FixedTimespan {
-                            utc_offset: utc_offset,
-                            dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
-                        });
-                    }
-                },
-
-                Saving::OneOff(amount) => {
-                    dst_offset = amount;
-                    start_zone_id = Some(timespan.format.format_constant());
-
-                    if insert_start_transition {
-                        let t = (start_time.unwrap(), FixedTimespan {
-                            utc_offset: utc_offset,
-                            dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
-                        });
-                        transitions.push(t);
-                        insert_start_transition = false;
-                    }
-                    else {
-                        first_transition = Some(FixedTimespan {
-                            utc_offset: utc_offset,
-                            dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
-                        });
-                    }
-                },
-
-                Saving::Multiple(ref rules) => {
-                    use datetime::DatePiece;
-
-                    for year in 1800..2100 {
-                        if use_until && year > LocalDateTime::at(timespan.end_time.unwrap().to_timestamp()).year() {
-                            break;
-                        }
-
-                        let mut activated_rules = self.rulesets[&*rules].iter()
-                                                      .filter(|r| r.applies_to_year(year))
-                                                      .collect::<Vec<_>>();
-
-                        loop {
-                            if use_until {
-                                until_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - dst_offset);
-                            }
-
-                            // Find the minimum rule based on the current UTC and DST offsets.
-                            // (this can be replaced with min_by when it stabilises):
-                            //.min_by(|r| r.1.absolute_datetime(year, utc_offset, dst_offset));
-                            let pos = {
-                                let earliest = activated_rules.iter().enumerate()
-                                    .map(|(i, r)| (r.absolute_datetime(year, utc_offset, dst_offset), i))
-                                    .min()
-                                    .map(|(_, i)| i);
-
-                                match earliest {
-                                    Some(p) => p,
-                                    None    => break,
-                                }
-                            };
-
-                            let earliest_rule = activated_rules.remove(pos);
-                            let earliest_at = earliest_rule.absolute_datetime(year, utc_offset, dst_offset).to_instant().seconds();
-
-                            if use_until && earliest_at >= until_time.unwrap() {
-                                break;
-                            }
-
-                            dst_offset = earliest_rule.time_to_add;
-
-                            if insert_start_transition && earliest_at == start_time.unwrap() {
-                                insert_start_transition = false;
-                            }
-
-                            if insert_start_transition {
-                                if earliest_at < start_time.unwrap() {
-                                    start_utc_offset = timespan.offset;
-                                    start_dst_offset = dst_offset;
-                                    start_zone_id = Some(timespan.format.format(dst_offset, earliest_rule.letters.as_ref()));
-                                    continue;
-                                }
-
-                                if start_zone_id.is_none() && start_utc_offset + start_dst_offset == timespan.offset + dst_offset {
-                                    start_zone_id = Some(timespan.format.format(dst_offset, earliest_rule.letters.as_ref()));
-                                }
-                            }
-
-                            let t = (earliest_at, FixedTimespan {
-                                utc_offset: timespan.offset,
-                                dst_offset: earliest_rule.time_to_add,
-                                name:       timespan.format.format(earliest_rule.time_to_add, earliest_rule.letters.as_ref()),
-                            });
-                            transitions.push(t);
-                        }
-                    }
-                }
-            }
-
-            if insert_start_transition && start_zone_id.is_some() {
-                let t = (start_time.expect("Start time"), FixedTimespan {
-                    utc_offset: start_utc_offset,
-                    dst_offset: start_dst_offset,
-                    name:       start_zone_id.clone().expect("Start zone ID"),
-                });
-                transitions.push(t);
-            }
-
-            if use_until {
-                start_time = Some(timespan.end_time.expect("End time").to_timestamp() - utc_offset - dst_offset);
-            }
-        }
-
-        transitions.sort_by(|a, b| a.0.cmp(&b.0));
-
-        let first = match first_transition {
-            Some(ft) => ft,
-            None     => transitions.iter().find(|t| t.1.dst_offset == 0).unwrap().1.clone(),
-        };
-
-        let mut zoneset = FixedTimespanSet {
-            first: first,
-            rest:  transitions,
-        };
-        optimise(&mut zoneset);
-        zoneset
-    }
 }
 
-#[allow(unused_results)]  // for remove
-fn optimise(transitions: &mut FixedTimespanSet) {
-    let mut from_i = 0;
-    let mut to_i = 0;
-
-    while from_i < transitions.rest.len() {
-        if to_i > 1 {
-            let from = transitions.rest[from_i].0;
-            let to = transitions.rest[to_i - 1].0;
-            if from + transitions.rest[to_i - 1].1.total_offset() <= to + transitions.rest[to_i - 2].1.total_offset() {
-                transitions.rest[to_i - 1].1 = transitions.rest[from_i].1.clone();
-                from_i += 1;
-                continue;
-            }
-        }
-
-        if to_i == 0 || transitions.rest[to_i - 1].1 != transitions.rest[from_i].1 {
-            transitions.rest[to_i] = transitions.rest[from_i].clone();
-            to_i += 1;
-        }
-
-        from_i += 1
-    }
-
-    transitions.rest.truncate(to_i);
-
-    if !transitions.rest.is_empty() && transitions.first == transitions.rest[0].1 {
-        transitions.rest.remove(0);
-    }
-}
 
 #[derive(PartialEq, Debug)]
 pub struct RuleInfo {
 
     /// The year that this rule *starts* applying.
-    from_year: YearSpec,
+    pub from_year: YearSpec,
 
     /// The year that this rule *finishes* applying, inclusive, or `None` if
     /// it applies up until the end of this timespan.
-    to_year: Option<YearSpec>,
+    pub to_year: Option<YearSpec>,
 
     /// The month it applies on.
-    month: MonthSpec,
+    pub month: MonthSpec,
 
     /// The day it applies on.
-    day: DaySpec,
+    pub day: DaySpec,
 
     /// The exact time it applies on.
-    time: i64,
+    pub time: i64,
 
     /// The type of time that time is.
-    time_type: TimeType,
+    pub time_type: TimeType,
 
     /// The amount of time to save.
-    time_to_add: i64,
+    pub time_to_add: i64,
 
     /// Any extra letters that should be added to this time zone’s
     /// abbreviation, in place of `%s`.
-    letters: Option<String>,
+    pub letters: Option<String>,
 }
 
 impl<'_> From<line::Rule<'_>> for RuleInfo {
@@ -345,7 +104,7 @@ impl<'_> From<line::Rule<'_>> for RuleInfo {
 }
 
 impl RuleInfo {
-    fn applies_to_year(&self, year: i64) -> bool {
+    pub fn applies_to_year(&self, year: i64) -> bool {
         use line::YearSpec::*;
 
         match (self.from_year, self.to_year) {
@@ -356,7 +115,7 @@ impl RuleInfo {
         }
     }
 
-    fn absolute_datetime(&self, year: i64, utc_offset: i64, dst_offset: i64) -> LocalDateTime {
+    pub fn absolute_datetime(&self, year: i64, utc_offset: i64, dst_offset: i64) -> LocalDateTime {
         use datetime::Duration;
 
         let offset = match self.time_type {
@@ -440,7 +199,7 @@ impl Format {
     /// Convert the template into one of the `Format` variants. This can’t
     /// fail, as any syntax that doesn’t match one of the two formats will
     /// just be a ‘constant’ format.
-    fn new(template: &str) -> Format {
+    pub fn new(template: &str) -> Format {
         if let Some(pos) = template.find('/') {
             Format::Alternate {
                 standard:  template[.. pos].to_owned(),
@@ -455,7 +214,7 @@ impl Format {
         }
     }
 
-    fn format(&self, dst_offset: i64, letters: Option<&String>) -> String {
+    pub fn format(&self, dst_offset: i64, letters: Option<&String>) -> String {
         let letters = match letters {
             Some(l) => &**l,
             None    => "",
@@ -469,7 +228,7 @@ impl Format {
         }
     }
 
-    fn format_constant(&self) -> String {
+    pub fn format_constant(&self) -> String {
         if let Format::Constant(ref s) = *self {
             s.clone()
         }
@@ -603,317 +362,3 @@ impl<'line> ErrorTrait for Error<'line> {
         None
     }
 }
-
-
-#[cfg(test)]
-mod test {
-
-    // Allow unused results in test code, because the only ‘results’ that
-    // we need to ignore are the ones from inserting and removing from
-    // tables and vectors. And as we set them up ourselves, they’re bound
-    // to be correct, otherwise the tests would fail!
-    #![allow(unused_results)]
-
-    use super::{FixedTimespan, FixedTimespanSet, Saving, ZoneInfo, RuleInfo, Table, Format, optimise};
-    use datetime::Weekday::*;
-    use datetime::Month::*;
-    use datetime::zone::TimeType;
-    use line::DaySpec;
-    use line::WeekdaySpec;
-    use line::MonthSpec;
-    use line::YearSpec;
-    use line::TimeSpec;
-    use line::ChangeTime;
-
-    #[test]
-    fn no_transitions() {
-        let zone = ZoneInfo {
-            offset: 1234,
-            format: Format::new("TEST"),
-            saving: Saving::NoSaving,
-            end_time: None,
-        };
-
-        let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), vec![ zone ]);
-
-        assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
-            first: FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned() },
-            rest:  vec![],
-        });
-    }
-
-    #[test]
-    fn one_transition() {
-        let zone_1 = ZoneInfo {
-            offset: 1234,
-            format: Format::new("TEST"),
-            saving: Saving::NoSaving,
-            end_time: Some(ChangeTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(2), TimeSpec::HoursMinutesSeconds(10, 17, 36).with_type(TimeType::UTC))),
-        };
-
-        let zone_2 = ZoneInfo {
-            offset: 5678,
-            format: Format::new("TSET"),
-            saving: Saving::NoSaving,
-            end_time: None,
-        };
-
-        let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), vec![ zone_1, zone_2 ]);
-
-        let expected = FixedTimespanSet {
-            first:       FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned() },
-            rest: vec![
-                (122222, FixedTimespan { utc_offset: 5678, dst_offset: 0, name: "TSET".to_owned() }),
-            ],
-        };
-
-        assert_eq!(table.timespans("Test/Zone"), expected);
-    }
-
-
-    #[test]
-    fn two_transitions() {
-        let zone_1 = ZoneInfo {
-            offset: 1234,
-            format: Format::new("TEST"),
-            saving: Saving::NoSaving,
-            end_time: Some(ChangeTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(2), TimeSpec::HoursMinutesSeconds(10, 17, 36).with_type(TimeType::Standard))),
-        };
-
-        let zone_2 = ZoneInfo {
-            offset: 3456,
-            format: Format::new("TSET"),
-            saving: Saving::NoSaving,
-            end_time: Some(ChangeTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(3), TimeSpec::HoursMinutesSeconds(17, 09, 27).with_type(TimeType::Standard))),
-        };
-
-        let zone_3 = ZoneInfo {
-            offset: 5678,
-            format: Format::new("ESTE"),
-            saving: Saving::NoSaving,
-            end_time: None,
-        };
-
-        let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), vec![ zone_1, zone_2, zone_3 ]);
-
-        let expected = FixedTimespanSet {
-            first: FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned(), },
-            rest: vec![
-                (122222, FixedTimespan {
-                    utc_offset: 3456,
-                    dst_offset: 0,
-                    name: "TSET".to_owned(),
-                }),
-                (231111, FixedTimespan {
-                    utc_offset: 5678,
-                    dst_offset: 0,
-                    name: "ESTE".to_owned(),
-                }),
-            ],
-        };
-
-        assert_eq!(table.timespans("Test/Zone"), expected);
-    }
-
-    #[test]
-    fn one_rule() {
-        let ruleset = vec![
-            RuleInfo {
-                from_year:   YearSpec::Number(1980),
-                to_year:     None,
-                month:       MonthSpec(February),
-                day:         DaySpec::Ordinal(4),
-                time:        0,
-                time_type:   TimeType::UTC,
-                time_to_add: 1000,
-                letters:     None,
-            }
-        ];
-
-        let lmt = ZoneInfo {
-            offset: 0,
-            format: Format::new("LMT"),
-            saving: Saving::NoSaving,
-            end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1980))),
-        };
-
-        let zone = ZoneInfo {
-            offset: 2000,
-            format: Format::new("TEST"),
-            saving: Saving::Multiple("Dwayne".to_owned()),
-            end_time: None,
-        };
-
-        let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), vec![ lmt, zone ]);
-        table.rulesets.insert("Dwayne".to_owned(), ruleset);
-
-        assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
-            first: FixedTimespan { utc_offset: 0, dst_offset: 0, name: "LMT".to_owned() },
-            rest:  vec![
-                (318_470_400, FixedTimespan { utc_offset: 2000, dst_offset: 1000, name: "TEST".to_owned() })
-            ],
-        });
-    }
-
-    #[test]
-    fn two_rules() {
-        let ruleset = vec![
-            RuleInfo {
-                from_year:   YearSpec::Number(1980),
-                to_year:     None,
-                month:       MonthSpec(February),
-                day:         DaySpec::Ordinal(4),
-                time:        0,
-                time_type:   TimeType::UTC,
-                time_to_add: 1000,
-                letters:     None,
-            },
-            RuleInfo {
-                from_year:   YearSpec::Number(1989),
-                to_year:     None,
-                month:       MonthSpec(January),
-                day:         DaySpec::Ordinal(12),
-                time:        0,
-                time_type:   TimeType::UTC,
-                time_to_add: 1500,
-                letters:     None,
-            },
-        ];
-
-        let lmt = ZoneInfo {
-            offset: 0,
-            format: Format::new("LMT"),
-            saving: Saving::NoSaving,
-            end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1980))),
-        };
-
-        let zone = ZoneInfo {
-            offset: 2000,
-            format: Format::new("TEST"),
-            saving: Saving::Multiple("Dwayne".to_owned()),
-            end_time: None,
-        };
-
-        let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), vec![ lmt, zone ]);
-        table.rulesets.insert("Dwayne".to_owned(), ruleset);
-
-        assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
-            first: FixedTimespan { utc_offset: 0, dst_offset: 0, name: "LMT".to_owned() },
-            rest: vec![
-                (318_470_400, FixedTimespan { utc_offset: 2000, dst_offset: 1000, name: "TEST".to_owned() }),
-                (600_566_400, FixedTimespan { utc_offset: 2000, dst_offset: 1500, name: "TEST".to_owned() }),
-            ],
-        });
-    }
-
-    #[test]
-    fn tripoli() {
-        let libya = vec![
-            RuleInfo { from_year: YearSpec::Number(1951), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(14),               time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1952), to_year: None,                         month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(1953), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(9),                time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1954), to_year: None,                         month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(1955), to_year: None,                         month: MonthSpec(September), day: DaySpec::Ordinal(30),               time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1956), to_year: None,                         month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(1982), to_year: Some(YearSpec::Number(1984)), month: MonthSpec(April),     day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1982), to_year: Some(YearSpec::Number(1985)), month: MonthSpec(October),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(1985), to_year: None,                         month: MonthSpec(April),     day: DaySpec::Ordinal(6),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1986), to_year: None,                         month: MonthSpec(April),     day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1986), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(3),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(1987), to_year: Some(YearSpec::Number(1989)), month: MonthSpec(April),     day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1987), to_year: Some(YearSpec::Number(1989)), month: MonthSpec(October),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(1997), to_year: None,                         month: MonthSpec(April),     day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(1997), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-            RuleInfo { from_year: YearSpec::Number(2013), to_year: None,                         month: MonthSpec(March),     day: DaySpec::Last(WeekdaySpec(Friday)), time: 3600, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
-            RuleInfo { from_year: YearSpec::Number(2013), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Last(WeekdaySpec(Friday)), time: 7200, time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
-        ];
-
-        let zone = vec![
-            ZoneInfo { offset: 3164, format: Format::new("LMT"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1920))) },
-            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1959)))  },
-            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1982)))   },
-            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilDay (YearSpec::Number(1990), MonthSpec(May),       DaySpec::Ordinal( 4)))   },
-            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilDay (YearSpec::Number(1996), MonthSpec(September), DaySpec::Ordinal(30)))   },
-            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilDay (YearSpec::Number(1997), MonthSpec(October),   DaySpec::Ordinal( 4)))   },
-            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilTime(YearSpec::Number(2012), MonthSpec(November),  DaySpec::Ordinal(10), TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall)))  },
-            ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilTime(YearSpec::Number(2013), MonthSpec(October),   DaySpec::Ordinal(25), TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall)))  },
-            ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: None              },
-        ];
-
-        let mut table = Table::default();
-        table.zonesets.insert("Test/Zone".to_owned(), zone);
-        table.rulesets.insert("Libya".to_owned(), libya);
-
-        assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
-            first: FixedTimespan { utc_offset: 3164,  dst_offset:    0,  name:  "LMT".to_owned() },
-            rest: vec![
-                (-1_577_926_364, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (  -574_902_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (  -568_087_200, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (  -512_175_600, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (  -504_928_800, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (  -449_888_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (  -441_856_800, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (  -347_158_800, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
-                (   378_684_000, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (   386_463_600, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (   402_271_200, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (   417_999_600, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (   433_807_200, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (   449_622_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (   465_429_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (   481_590_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (   496_965_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (   512_953_200, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (   528_674_400, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (   544_230_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (   560_037_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (   575_852_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (   591_660_000, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (   607_388_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (   623_196_000, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (   641_775_600, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
-                (   844_034_400, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                (   860_108_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                (   875_916_000, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
-                ( 1_352_505_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
-                ( 1_364_515_200, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
-                ( 1_382_659_200, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
-            ],
-        });
-    }
-
-    #[test]
-    fn optimise_macquarie() {
-        let mut transitions = FixedTimespanSet {
-            first: FixedTimespan { utc_offset:     0, dst_offset:    0, name:  "zzz".to_owned() },
-            rest: vec![
-                (-2_214_259_200, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
-                (-1_680_508_800, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
-                (-1_669_892_400, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),  // gets removed
-                (-1_665_392_400, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
-                (-1_601_719_200, FixedTimespan { utc_offset:     0,  dst_offset:    0,  name:  "zzz".to_owned() }),
-                (  -687_052_800, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
-                (   -94_730_400, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),  // also gets removed
-                (   -71_136_000, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
-                (   -55_411_200, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
-                (   -37_267_200, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
-                (   -25_776_000, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
-                (    -5_817_600, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
-            ],
-        };
-
-        let mut result = transitions.clone();
-        result.rest.remove(6);
-        result.rest.remove(2);
-
-        optimise(&mut transitions);
-        assert_eq!(transitions, result);
-    }
-
-}
diff --git a/src/transitions.rs b/src/transitions.rs
new file mode 100644
index 0000000..7d2bb84
--- /dev/null
+++ b/src/transitions.rs
@@ -0,0 +1,295 @@
+use table::{Table, Saving};
+use datetime::LocalDateTime;
+
+
+/// A set of timespans, separated by the instances at which the timespans
+/// change over. There will always be one more timespan than transitions.
+///
+/// This mimics the `FixedTimespanSet` struct in `datetime::cal::zone`,
+/// except it uses owned `Vec`s instead of slices.
+#[derive(PartialEq, Debug, Clone)]
+pub struct FixedTimespanSet {
+
+    /// The first timespan, which is assumed to have been in effect up until
+    /// the initial transition instant (if any). Each set has to have at
+    /// least one timespan.
+    pub first: FixedTimespan,
+
+    /// The rest of the timespans, as a vector of tuples, each containing:
+    ///
+    /// 1. A transition instant at which the previous timespan ends and the
+    ///    next one begins, stored as a Unix timestamp;
+    /// 2. The actual timespan to transition into.
+    pub rest: Vec<(i64, FixedTimespan)>,
+}
+
+
+/// An individual timespan with a fixed offset.
+///
+/// This mimics the `FixedTimespan` struct in `datetime::cal::zone`, except
+/// instead of “total offset” and “is DST” fields, it has separate UTC and
+/// DST fields. Also, the name is an owned `String` here instead of a slice.
+#[derive(PartialEq, Debug, Clone)]
+pub struct FixedTimespan {
+
+    /// The number of seconds offset from UTC during this timespan.
+    pub utc_offset: i64,
+
+    /// The number of *extra* daylight-saving seconds during this timespan.
+    pub dst_offset: i64,
+
+    /// The abbreviation in use during this timespan.
+    pub name: String,
+}
+
+impl FixedTimespan {
+
+    /// The total offset in effect during this timespan.
+    pub fn total_offset(&self) -> i64 {
+        self.utc_offset + self.dst_offset
+    }
+}
+
+
+pub trait TableTransitions {
+    fn timespans(&self, zone_name: &str) -> FixedTimespanSet;
+}
+
+
+impl TableTransitions for Table {
+
+    /// Computes a fixed timespan set for the timezone with the given name.
+    fn timespans(&self, zone_name: &str) -> FixedTimespanSet {
+        let mut transitions = Vec::new();
+        let mut start_time = None;
+        let mut until_time = None;
+
+        let mut first_transition = None;
+
+        let zoneset = self.get_zoneset(zone_name);
+        for (i, timespan) in zoneset.iter().enumerate() {
+            let mut dst_offset = 0;
+            let use_until      = i != zoneset.len() - 1;
+            let utc_offset     = timespan.offset;
+
+            let mut insert_start_transition = i > 0;
+            let mut start_zone_id = None;
+            let mut start_utc_offset = timespan.offset;
+            let mut start_dst_offset = 0;
+
+            match timespan.saving {
+                Saving::NoSaving => {
+                    dst_offset = 0;
+                    start_zone_id = Some(timespan.format.format_constant());
+
+                    if insert_start_transition {
+                        let t = (start_time.unwrap(), FixedTimespan {
+                            utc_offset: utc_offset,
+                            dst_offset: dst_offset,
+                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
+                        });
+                        transitions.push(t);
+                        insert_start_transition = false;
+                    }
+                    else {
+                        first_transition = Some(FixedTimespan {
+                            utc_offset: utc_offset,
+                            dst_offset: dst_offset,
+                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
+                        });
+                    }
+                },
+
+                Saving::OneOff(amount) => {
+                    dst_offset = amount;
+                    start_zone_id = Some(timespan.format.format_constant());
+
+                    if insert_start_transition {
+                        let t = (start_time.unwrap(), FixedTimespan {
+                            utc_offset: utc_offset,
+                            dst_offset: dst_offset,
+                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
+                        });
+                        transitions.push(t);
+                        insert_start_transition = false;
+                    }
+                    else {
+                        first_transition = Some(FixedTimespan {
+                            utc_offset: utc_offset,
+                            dst_offset: dst_offset,
+                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
+                        });
+                    }
+                },
+
+                Saving::Multiple(ref rules) => {
+                    use datetime::DatePiece;
+
+                    for year in 1800..2100 {
+                        if use_until && year > LocalDateTime::at(timespan.end_time.unwrap().to_timestamp()).year() {
+                            break;
+                        }
+
+                        let mut activated_rules = self.rulesets[&*rules].iter()
+                                                      .filter(|r| r.applies_to_year(year))
+                                                      .collect::<Vec<_>>();
+
+                        loop {
+                            if use_until {
+                                until_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - dst_offset);
+                            }
+
+                            // Find the minimum rule based on the current UTC and DST offsets.
+                            // (this can be replaced with min_by when it stabilises):
+                            //.min_by(|r| r.1.absolute_datetime(year, utc_offset, dst_offset));
+                            let pos = {
+                                let earliest = activated_rules.iter().enumerate()
+                                    .map(|(i, r)| (r.absolute_datetime(year, utc_offset, dst_offset), i))
+                                    .min()
+                                    .map(|(_, i)| i);
+
+                                match earliest {
+                                    Some(p) => p,
+                                    None    => break,
+                                }
+                            };
+
+                            let earliest_rule = activated_rules.remove(pos);
+                            let earliest_at = earliest_rule.absolute_datetime(year, utc_offset, dst_offset).to_instant().seconds();
+
+                            if use_until && earliest_at >= until_time.unwrap() {
+                                break;
+                            }
+
+                            dst_offset = earliest_rule.time_to_add;
+
+                            if insert_start_transition && earliest_at == start_time.unwrap() {
+                                insert_start_transition = false;
+                            }
+
+                            if insert_start_transition {
+                                if earliest_at < start_time.unwrap() {
+                                    start_utc_offset = timespan.offset;
+                                    start_dst_offset = dst_offset;
+                                    start_zone_id = Some(timespan.format.format(dst_offset, earliest_rule.letters.as_ref()));
+                                    continue;
+                                }
+
+                                if start_zone_id.is_none() && start_utc_offset + start_dst_offset == timespan.offset + dst_offset {
+                                    start_zone_id = Some(timespan.format.format(dst_offset, earliest_rule.letters.as_ref()));
+                                }
+                            }
+
+                            let t = (earliest_at, FixedTimespan {
+                                utc_offset: timespan.offset,
+                                dst_offset: earliest_rule.time_to_add,
+                                name:       timespan.format.format(earliest_rule.time_to_add, earliest_rule.letters.as_ref()),
+                            });
+                            transitions.push(t);
+                        }
+                    }
+                }
+            }
+
+            if insert_start_transition && start_zone_id.is_some() {
+                let t = (start_time.expect("Start time"), FixedTimespan {
+                    utc_offset: start_utc_offset,
+                    dst_offset: start_dst_offset,
+                    name:       start_zone_id.clone().expect("Start zone ID"),
+                });
+                transitions.push(t);
+            }
+
+            if use_until {
+                start_time = Some(timespan.end_time.expect("End time").to_timestamp() - utc_offset - dst_offset);
+            }
+        }
+
+        transitions.sort_by(|a, b| a.0.cmp(&b.0));
+
+        let first = match first_transition {
+            Some(ft) => ft,
+            None     => transitions.iter().find(|t| t.1.dst_offset == 0).unwrap().1.clone(),
+        };
+
+        let mut zoneset = FixedTimespanSet {
+            first: first,
+            rest:  transitions,
+        };
+        optimise(&mut zoneset);
+        zoneset
+    }
+}
+
+
+#[allow(unused_results)]  // for remove
+fn optimise(transitions: &mut FixedTimespanSet) {
+    let mut from_i = 0;
+    let mut to_i = 0;
+
+    while from_i < transitions.rest.len() {
+        if to_i > 1 {
+            let from = transitions.rest[from_i].0;
+            let to = transitions.rest[to_i - 1].0;
+            if from + transitions.rest[to_i - 1].1.total_offset() <= to + transitions.rest[to_i - 2].1.total_offset() {
+                transitions.rest[to_i - 1].1 = transitions.rest[from_i].1.clone();
+                from_i += 1;
+                continue;
+            }
+        }
+
+        if to_i == 0 || transitions.rest[to_i - 1].1 != transitions.rest[from_i].1 {
+            transitions.rest[to_i] = transitions.rest[from_i].clone();
+            to_i += 1;
+        }
+
+        from_i += 1
+    }
+
+    transitions.rest.truncate(to_i);
+
+    if !transitions.rest.is_empty() && transitions.first == transitions.rest[0].1 {
+        transitions.rest.remove(0);
+    }
+}
+
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use super::optimise;
+
+    // Allow unused results in test code, because the only ‘results’ that
+    // we need to ignore are the ones from inserting and removing from
+    // tables and vectors. And as we set them up ourselves, they’re bound
+    // to be correct, otherwise the tests would fail!
+    #[test]
+    #[allow(unused_results)]
+    fn optimise_macquarie() {
+        let mut transitions = FixedTimespanSet {
+            first: FixedTimespan { utc_offset:     0, dst_offset:    0, name:  "zzz".to_owned() },
+            rest: vec![
+                (-2_214_259_200, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (-1_680_508_800, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+                (-1_669_892_400, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),  // gets removed
+                (-1_665_392_400, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (-1_601_719_200, FixedTimespan { utc_offset:     0,  dst_offset:    0,  name:  "zzz".to_owned() }),
+                (  -687_052_800, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (   -94_730_400, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),  // also gets removed
+                (   -71_136_000, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+                (   -55_411_200, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (   -37_267_200, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+                (   -25_776_000, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (    -5_817_600, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+            ],
+        };
+
+        let mut result = transitions.clone();
+        result.rest.remove(6);
+        result.rest.remove(2);
+
+        optimise(&mut transitions);
+        assert_eq!(transitions, result);
+    }
+}
diff --git a/tests/transition_tests.rs b/tests/transition_tests.rs
new file mode 100644
index 0000000..2b092c2
--- /dev/null
+++ b/tests/transition_tests.rs
@@ -0,0 +1,272 @@
+extern crate zoneinfo_parse;
+extern crate datetime;
+
+use zoneinfo_parse::line::{DaySpec, WeekdaySpec, MonthSpec, YearSpec, TimeSpec, ChangeTime};
+use zoneinfo_parse::table::{Saving, ZoneInfo, RuleInfo, Table, Format};
+use zoneinfo_parse::transitions::{FixedTimespan, FixedTimespanSet, TableTransitions};
+use datetime::Weekday::*;
+use datetime::Month::*;
+use datetime::zone::TimeType;
+
+#[test]
+fn no_transitions() {
+    let zone = ZoneInfo {
+        offset: 1234,
+        format: Format::new("TEST"),
+        saving: Saving::NoSaving,
+        end_time: None,
+    };
+
+    let mut table = Table::default();
+    table.zonesets.insert("Test/Zone".to_owned(), vec![ zone ]);
+
+    assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+        first: FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned() },
+        rest:  vec![],
+    });
+}
+
+#[test]
+fn one_transition() {
+    let zone_1 = ZoneInfo {
+        offset: 1234,
+        format: Format::new("TEST"),
+        saving: Saving::NoSaving,
+        end_time: Some(ChangeTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(2), TimeSpec::HoursMinutesSeconds(10, 17, 36).with_type(TimeType::UTC))),
+    };
+
+    let zone_2 = ZoneInfo {
+        offset: 5678,
+        format: Format::new("TSET"),
+        saving: Saving::NoSaving,
+        end_time: None,
+    };
+
+    let mut table = Table::default();
+    table.zonesets.insert("Test/Zone".to_owned(), vec![ zone_1, zone_2 ]);
+
+    let expected = FixedTimespanSet {
+        first:       FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned() },
+        rest: vec![
+            (122222, FixedTimespan { utc_offset: 5678, dst_offset: 0, name: "TSET".to_owned() }),
+        ],
+    };
+
+    assert_eq!(table.timespans("Test/Zone"), expected);
+}
+
+
+#[test]
+fn two_transitions() {
+    let zone_1 = ZoneInfo {
+        offset: 1234,
+        format: Format::new("TEST"),
+        saving: Saving::NoSaving,
+        end_time: Some(ChangeTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(2), TimeSpec::HoursMinutesSeconds(10, 17, 36).with_type(TimeType::Standard))),
+    };
+
+    let zone_2 = ZoneInfo {
+        offset: 3456,
+        format: Format::new("TSET"),
+        saving: Saving::NoSaving,
+        end_time: Some(ChangeTime::UntilTime(YearSpec::Number(1970), MonthSpec(January), DaySpec::Ordinal(3), TimeSpec::HoursMinutesSeconds(17, 09, 27).with_type(TimeType::Standard))),
+    };
+
+    let zone_3 = ZoneInfo {
+        offset: 5678,
+        format: Format::new("ESTE"),
+        saving: Saving::NoSaving,
+        end_time: None,
+    };
+
+    let mut table = Table::default();
+    table.zonesets.insert("Test/Zone".to_owned(), vec![ zone_1, zone_2, zone_3 ]);
+
+    let expected = FixedTimespanSet {
+        first: FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned(), },
+        rest: vec![
+            (122222, FixedTimespan {
+                utc_offset: 3456,
+                dst_offset: 0,
+                name: "TSET".to_owned(),
+            }),
+            (231111, FixedTimespan {
+                utc_offset: 5678,
+                dst_offset: 0,
+                name: "ESTE".to_owned(),
+            }),
+        ],
+    };
+
+    assert_eq!(table.timespans("Test/Zone"), expected);
+}
+
+#[test]
+fn one_rule() {
+    let ruleset = vec![
+        RuleInfo {
+            from_year:   YearSpec::Number(1980),
+            to_year:     None,
+            month:       MonthSpec(February),
+            day:         DaySpec::Ordinal(4),
+            time:        0,
+            time_type:   TimeType::UTC,
+            time_to_add: 1000,
+            letters:     None,
+        }
+    ];
+
+    let lmt = ZoneInfo {
+        offset: 0,
+        format: Format::new("LMT"),
+        saving: Saving::NoSaving,
+        end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1980))),
+    };
+
+    let zone = ZoneInfo {
+        offset: 2000,
+        format: Format::new("TEST"),
+        saving: Saving::Multiple("Dwayne".to_owned()),
+        end_time: None,
+    };
+
+    let mut table = Table::default();
+    table.zonesets.insert("Test/Zone".to_owned(), vec![ lmt, zone ]);
+    table.rulesets.insert("Dwayne".to_owned(), ruleset);
+
+    assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+        first: FixedTimespan { utc_offset: 0, dst_offset: 0, name: "LMT".to_owned() },
+        rest:  vec![
+            (318_470_400, FixedTimespan { utc_offset: 2000, dst_offset: 1000, name: "TEST".to_owned() })
+        ],
+    });
+}
+
+#[test]
+fn two_rules() {
+    let ruleset = vec![
+        RuleInfo {
+            from_year:   YearSpec::Number(1980),
+            to_year:     None,
+            month:       MonthSpec(February),
+            day:         DaySpec::Ordinal(4),
+            time:        0,
+            time_type:   TimeType::UTC,
+            time_to_add: 1000,
+            letters:     None,
+        },
+        RuleInfo {
+            from_year:   YearSpec::Number(1989),
+            to_year:     None,
+            month:       MonthSpec(January),
+            day:         DaySpec::Ordinal(12),
+            time:        0,
+            time_type:   TimeType::UTC,
+            time_to_add: 1500,
+            letters:     None,
+        },
+    ];
+
+    let lmt = ZoneInfo {
+        offset: 0,
+        format: Format::new("LMT"),
+        saving: Saving::NoSaving,
+        end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1980))),
+    };
+
+    let zone = ZoneInfo {
+        offset: 2000,
+        format: Format::new("TEST"),
+        saving: Saving::Multiple("Dwayne".to_owned()),
+        end_time: None,
+    };
+
+    let mut table = Table::default();
+    table.zonesets.insert("Test/Zone".to_owned(), vec![ lmt, zone ]);
+    table.rulesets.insert("Dwayne".to_owned(), ruleset);
+
+    assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+        first: FixedTimespan { utc_offset: 0, dst_offset: 0, name: "LMT".to_owned() },
+        rest: vec![
+            (318_470_400, FixedTimespan { utc_offset: 2000, dst_offset: 1000, name: "TEST".to_owned() }),
+            (600_566_400, FixedTimespan { utc_offset: 2000, dst_offset: 1500, name: "TEST".to_owned() }),
+        ],
+    });
+}
+
+#[test]
+fn tripoli() {
+    let libya = vec![
+        RuleInfo { from_year: YearSpec::Number(1951), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(14),               time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+        RuleInfo { from_year: YearSpec::Number(1952), to_year: None,                         month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+        RuleInfo { from_year: YearSpec::Number(1953), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(9),                time: 7200, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+        RuleInfo { from_year: YearSpec::Number(1954), to_year: None,                         month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+        RuleInfo { from_year: YearSpec::Number(1955), to_year: None,                         month: MonthSpec(September), day: DaySpec::Ordinal(30),               time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+        RuleInfo { from_year: YearSpec::Number(1956), to_year: None,                         month: MonthSpec(January),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+        RuleInfo { from_year: YearSpec::Number(1982), to_year: Some(YearSpec::Number(1984)), month: MonthSpec(April),     day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+        RuleInfo { from_year: YearSpec::Number(1982), to_year: Some(YearSpec::Number(1985)), month: MonthSpec(October),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+        RuleInfo { from_year: YearSpec::Number(1985), to_year: None,                         month: MonthSpec(April),     day: DaySpec::Ordinal(6),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+        RuleInfo { from_year: YearSpec::Number(1986), to_year: None,                         month: MonthSpec(April),     day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+        RuleInfo { from_year: YearSpec::Number(1986), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(3),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+        RuleInfo { from_year: YearSpec::Number(1987), to_year: Some(YearSpec::Number(1989)), month: MonthSpec(April),     day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+        RuleInfo { from_year: YearSpec::Number(1987), to_year: Some(YearSpec::Number(1989)), month: MonthSpec(October),   day: DaySpec::Ordinal(1),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+        RuleInfo { from_year: YearSpec::Number(1997), to_year: None,                         month: MonthSpec(April),     day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+        RuleInfo { from_year: YearSpec::Number(1997), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Ordinal(4),                time: 0,    time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+        RuleInfo { from_year: YearSpec::Number(2013), to_year: None,                         month: MonthSpec(March),     day: DaySpec::Last(WeekdaySpec(Friday)), time: 3600, time_type: TimeType::Wall, time_to_add: 3600, letters: Some("S".to_owned()) },
+        RuleInfo { from_year: YearSpec::Number(2013), to_year: None,                         month: MonthSpec(October),   day: DaySpec::Last(WeekdaySpec(Friday)), time: 7200, time_type: TimeType::Wall, time_to_add: 0,    letters: None                 },
+    ];
+
+    let zone = vec![
+        ZoneInfo { offset: 3164, format: Format::new("LMT"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1920))) },
+        ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1959)))  },
+        ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilYear(YearSpec::Number(1982)))   },
+        ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilDay (YearSpec::Number(1990), MonthSpec(May),       DaySpec::Ordinal( 4)))   },
+        ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilDay (YearSpec::Number(1996), MonthSpec(September), DaySpec::Ordinal(30)))   },
+        ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilDay (YearSpec::Number(1997), MonthSpec(October),   DaySpec::Ordinal( 4)))   },
+        ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: Some(ChangeTime::UntilTime(YearSpec::Number(2012), MonthSpec(November),  DaySpec::Ordinal(10), TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall)))  },
+        ZoneInfo { offset: 3600, format: Format::new("CE%sT"), saving: Saving::Multiple("Libya".to_owned()), end_time: Some(ChangeTime::UntilTime(YearSpec::Number(2013), MonthSpec(October),   DaySpec::Ordinal(25), TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall)))  },
+        ZoneInfo { offset: 7200, format: Format::new("EET"),   saving: Saving::NoSaving,                     end_time: None              },
+    ];
+
+    let mut table = Table::default();
+    table.zonesets.insert("Test/Zone".to_owned(), zone);
+    table.rulesets.insert("Libya".to_owned(), libya);
+
+    assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+        first: FixedTimespan { utc_offset: 3164,  dst_offset:    0,  name:  "LMT".to_owned() },
+        rest: vec![
+            (-1_577_926_364, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (  -574_902_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (  -568_087_200, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (  -512_175_600, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (  -504_928_800, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (  -449_888_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (  -441_856_800, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (  -347_158_800, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
+            (   378_684_000, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (   386_463_600, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (   402_271_200, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (   417_999_600, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (   433_807_200, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (   449_622_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (   465_429_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (   481_590_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (   496_965_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (   512_953_200, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (   528_674_400, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (   544_230_000, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (   560_037_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (   575_852_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (   591_660_000, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (   607_388_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (   623_196_000, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (   641_775_600, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
+            (   844_034_400, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            (   860_108_400, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            (   875_916_000, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
+            ( 1_352_505_600, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
+            ( 1_364_515_200, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
+            ( 1_382_659_200, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
+        ],
+    });
+}

From 6a02d206325ef5dcb2edc048e174ac4628a7d2e9 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 4 Dec 2015 15:47:31 +0000
Subject: [PATCH 039/113] Documentation improvements

---
 src/lib.rs         |   2 +-
 src/structure.rs   |   2 +-
 src/table.rs       |  68 +++++++++++++++++++++--------
 src/transitions.rs | 106 +++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 158 insertions(+), 20 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 124fa60..965c714 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,7 +6,7 @@
 
 #![warn(missing_copy_implementations)]
 #![warn(missing_debug_implementations)]
-//#![warn(missing_docs)]
+#![warn(missing_docs)]
 
 #![warn(trivial_casts, trivial_numeric_casts)]
 #![warn(unused_qualifications)]
diff --git a/src/structure.rs b/src/structure.rs
index d0fc6aa..73ce7a6 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -38,7 +38,7 @@ use table::Table;
 /// Trait to put the `structure` method on Tables.
 pub trait Structure {
 
-    /// The **Structure** of the zonesets.
+    /// Returns an iterator over the structure of this table.
     fn structure(&self) -> TableStructure;
 }
 
diff --git a/src/table.rs b/src/table.rs
index 0ae3535..da7b807 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -1,19 +1,17 @@
 //! Collecting parsed zoneinfo data lines into a set of time zone data.
 //!
 //! This module provides the `Table` struct, which is able to take parsed
-//! lines of input from the `line` module and put them together, producing a
-//! list of time zone transitions that can be written to files.
+//! lines of input from the `line` module and coalesce them into a single
+//! set of data.
 //!
-//! It’s not as simple as it seems, because:
+//! It’s not as simple as it seems, because the zoneinfo data lines refer to
+//! each other through strings: lines of the form "link zone A to B" could be
+//! *parsed* successfully but still fail to be *interpreted* successfully if
+//! "B" doesn't exist. So it has to check every step of the way—nothing wrong
+//! with this, it's just a consequence of reading data from a text file.
 //!
-//! 1. The zoneinfo data lines refer to each other through strings, such as
-//!    “link zone A to B”; lines of that form could be *parsed* successfully
-//!    but still fail to be interpreted if “B” doesn’t exist. So it has to
-//!    check every step of the way. Nothing wrong with this, it’s just a
-//!    consequence of reading data from a text file.
-//! 2. We output the list of time zones as a set of timespans and
-//!    transitions. The logic for doing this is really complicated (see
-//!    ‘zic.c’, which has the same logic, only in C).
+//! This module only deals with constructing a table from data: any analysis
+//! of the data is done elsewhere.
 
 use std::collections::hash_map::{HashMap, Entry};
 use std::error::Error as ErrorTrait;
@@ -58,6 +56,11 @@ impl Table {
 }
 
 
+/// An owned rule definition line.
+///
+/// This mimics the `Rule` struct in the `line` module, only its uses owned
+/// Strings instead of string slices, and has had some pre-processing
+/// applied to it.
 #[derive(PartialEq, Debug)]
 pub struct RuleInfo {
 
@@ -104,6 +107,8 @@ impl<'_> From<line::Rule<'_>> for RuleInfo {
 }
 
 impl RuleInfo {
+
+    /// Returns whether this rule is in effect during the given year.
     pub fn applies_to_year(&self, year: i64) -> bool {
         use line::YearSpec::*;
 
@@ -115,6 +120,7 @@ impl RuleInfo {
         }
     }
 
+    /// Calculates a
     pub fn absolute_datetime(&self, year: i64, utc_offset: i64, dst_offset: i64) -> LocalDateTime {
         use datetime::Duration;
 
@@ -130,12 +136,31 @@ impl RuleInfo {
     }
 }
 
+
+/// An owned zone definition line.
+///
+/// This struct mimics the `ZoneInfo` struct in the `line` module, *not* the
+/// `Zone` struct, which is the key name in the map—this is just the value.
+///
+/// As with `RuleInfo`, this struct uses owned Strings rather than string
+/// slices.
 #[derive(PartialEq, Debug)]
 pub struct ZoneInfo {
-    pub offset:    i64,
-    pub format:    Format,
-    pub saving:    Saving,
-    pub end_time:  Option<ChangeTime>,
+
+    /// The number of seconds that need to be added to UTC to get the
+    /// standard time in this zone.
+    pub offset: i64,
+
+    /// The name of all the rules that should apply in the time zone, or the
+    /// amount of daylight-saving time to add.
+    pub saving: Saving,
+
+    /// The format for time zone abbreviations.
+    pub format: Format,
+
+    /// The time at which the rules change for this time zone, or `None` if
+    /// these rules are in effect until the end of time (!).
+    pub end_time: Option<ChangeTime>,
 }
 
 impl<'_> From<line::ZoneInfo<'_>> for ZoneInfo {
@@ -185,9 +210,15 @@ pub enum Format {
     Constant(String),
 
     /// An alternate format, such as “PST/PDT”, which changes between
-    /// standard and DST timespans (the first option is standard, the second
-    /// is DST).
-    Alternate { standard: String, dst: String },
+    /// standard and DST timespans.
+    Alternate {
+
+        /// Abbreviation to use during Standard Time.
+        standard: String,
+
+        /// Abbreviation to use during Summer Time.
+        dst: String,
+    },
 
     /// A format with a placeholder `%s`, which uses the `letters` field in
     /// a `RuleInfo` to generate the time zone abbreviation.
@@ -330,6 +361,7 @@ impl TableBuilder {
 }
 
 
+/// Something that can go wrong while constructing a `Table`.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub enum Error<'line> {
 
diff --git a/src/transitions.rs b/src/transitions.rs
index 7d2bb84..8c761ae 100644
--- a/src/transitions.rs
+++ b/src/transitions.rs
@@ -1,3 +1,106 @@
+//! Generating timespan sets from a built Table.
+//!
+//! Once a table has been fully built, it needs to be turned into several
+//! *fixed timespan sets*: a series of spans of time where the local time
+//! offset remains the same throughout. One set is generated for each named
+//! time zone. These timespan sets can then be iterated over to produce
+//! *transitions*: when the local time changes from one offset to another.
+//!
+//! These sets are returned as `FixedTimespanSet` values, rather than
+//! iterators, because the generation logic does not output the timespans
+//! in any particular order, meaning they need to be sorted before they’re
+//! returned—so we may as well just return the vector, rather than an
+//! iterator over the vector.
+//!
+//! Similarly, there is a fixed set of years that is iterated over
+//! (currently 1800..2100), rather than having an iterator that produces
+//! timespans indefinitely. Not only do we need a complete set of timespans
+//! for sorting, but it is not necessarily advisable to rely on offset
+//! changes so far into the future!
+//!
+//! ### Example
+//!
+//! The complete definition of the `Indian/Mauritius` time zone, as
+//! specified in the `africa` file in my version of the tz database, has
+//! two Zone definitions, one of which refers to four Rule definitions:
+//!
+//! ```tz
+//! # Rule      NAME    FROM    TO      TYPE    IN      ON      AT      SAVE    LETTER/S
+//! Rule Mauritius      1982    only    -       Oct     10      0:00    1:00    S
+//! Rule Mauritius      1983    only    -       Mar     21      0:00    0       -
+//! Rule Mauritius      2008    only    -       Oct     lastSun 2:00    1:00    S
+//! Rule Mauritius      2009    only    -       Mar     lastSun 2:00    0       -
+//!
+//! # Zone      NAME            GMTOFF  RULES   FORMAT  [UNTIL]
+//! Zone Indian/Mauritius       3:50:00 -       LMT     1907   # Port Louis
+//!                             4:00 Mauritius  MU%sT          # Mauritius Time
+//! ```
+//!
+//! To generate a fixed timespan set for this timezone, we examine each of the
+//! Zone definitions, generating at least one timespan for each definition.
+//!
+//! * The first timespan describes the *local mean time* (LMT) in Mauritius,
+//!   calculated by the geographical position of Port Louis, its capital.
+//!   Although it’s common to have a timespan set begin with a city’s local mean
+//!   time, it is by no means necessary. This timespan has a fixed offset of
+//!   three hours and fifty minutes ahead of UTC, and lasts until the beginning
+//!   of 1907, at which point the second timespan kicks in.
+//! * The second timespan has no ‘until’ date, so it’s in effect indefinitely.
+//!   Instead of having a fixed offset, it refers to the set of rules under the
+//!   name “Mauritius”, which we’ll have to consult to compute the timespans.
+//!     * The first two rules refer to a summer time transition that began on
+//!       the 10th of October 1982, and lasted until the 21st of March 1983. But
+//!       before we get onto that, we need to add a timespan beginning at the
+//!       time the last one ended (1907), up until the point Summer Time kicks
+//!       in (1982), reflecting that it was four hours ahead of UTC.
+//!     * After this, we add another timespan for Summer Time, when Mauritius
+//!       was an extra hour ahead, bringing the total offset for that time to
+//!       *five* hours.
+//!     * The next (and last) two rules refer to another summer time
+//!       transition from the last Sunday of October 2008 to the last Sunday of
+//!       March 2009, this time at 2am local time instead of midnight. But, as
+//!       before, we need to add a *standard* time timespan beginning at the
+//!       time Summer Time ended (1983) up until the point the next span of
+//!       Summer Time kicks in (2008), again reflecting that it was four hours
+//!       ahead of UTC again.
+//!     * Next, we add the Summer Time timespan, again bringing the total
+//!       offset to five hours. We need to calculate when the last Sundays of
+//!       the months are to get the dates correct.
+//!     * Finally, we add one last standard time timespan, lasting from 2009
+//!       indefinitely, as the Mauritian authorities decided not to change to
+//!       Summer Time again.
+//!
+//! All this calculation results in the following six timespans to be added:
+//!
+//! | Timespan start            | Abbreviation | UTC offset         | DST? |
+//! |:--------------------------|:-------------|:-------------------|:-----|
+//! | *no start*                | LMT          | 3 hours 50 minutes | No   |
+//! | 1906-11-31 T 20:10:00 UTC | MUT          | 4 hours            | No   |
+//! | 1982-09-09 T 20:00:00 UTC | MUST         | 5 hours            | Yes  |
+//! | 1983-02-20 T 19:00:00 UTC | MUT          | 4 hours            | No   |
+//! | 2008-09-25 T 22:00:00 UTC | MUST         | 5 hours            | Yes  |
+//! | 2009-02-28 T 21:00:00 UTC | MUT          | 4 hours            | No   |
+//!
+//! There are a few final things of note:
+//!
+//! Firstly, this library records the times that timespans *begin*, while
+//! the tz data files record the times that timespans *end*. Pay attention to
+//! this if the timestamps aren’t where you expect them to be! For example, in
+//! the data file, the first zone rule has an ‘until’ date and the second has
+//! none, whereas in the list of timespans, the last timespan has a ‘start’
+//! date and the *first* has none.
+//!
+//! Secondly, although local mean time in Mauritius lasted until 1907, the
+//! timespan is recorded as ending in 1906! Why is this? It’s because the
+//! transition occurred at midnight *at the local time*, which in this case,
+//! was three hours fifty minutes ahead of UTC. So that time has to be
+//! *subtracted* from the date, resulting in twenty hours and ten minutes on
+//! the last day of the year. Similar things happen on the rest of the
+//! transitions, being either four or five hours ahead of UTC.
+//!
+//! The logic in this file is based off of `zic.c`, which comes with the
+//! zoneinfo files and is in the public domain.
+
 use table::{Table, Saving};
 use datetime::LocalDateTime;
 
@@ -51,7 +154,10 @@ impl FixedTimespan {
 }
 
 
+/// Trait to put the `timespans` method on Tables.
 pub trait TableTransitions {
+
+    /// The
     fn timespans(&self, zone_name: &str) -> FixedTimespanSet;
 }
 

From d2c81607e3f0371de9780ccadaea37c62ac84196 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sat, 5 Dec 2015 20:35:32 +0000
Subject: [PATCH 040/113] Fix the data crate's comments' timestamps' formats

Attack of the killer apostrophes!

The explanatory timestamps in the comments had the wrong number months, and this way we can use the new ISO formatting that the datetime crate provides.
---
 bin/build-data-crate.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bin/build-data-crate.rs b/bin/build-data-crate.rs
index 507de21..9ff0fb9 100644
--- a/bin/build-data-crate.rs
+++ b/bin/build-data-crate.rs
@@ -8,7 +8,7 @@ use std::path::{Path, PathBuf};
 use std::process::exit;
 
 extern crate datetime;
-use datetime::LocalDateTime;
+use datetime::{LocalDateTime, ISO};
 
 extern crate zoneinfo_parse;
 use zoneinfo_parse::line::{Line};
@@ -200,7 +200,7 @@ impl DataCrate {
             try!(writeln!(w, "        rest: &["));
 
             for t in &set.rest {
-                try!(writeln!(w, "        ({:?}, FixedTimespan {{  // {:?} UTC", t.0, LocalDateTime::at(t.0)));
+                try!(writeln!(w, "        ({:?}, FixedTimespan {{  // {} UTC", t.0, LocalDateTime::at(t.0).iso()));
 
                 // Write the total offset (the only value that gets used)
                 // and both the offsets that get added together, as a

From 853f280da6bf7aca6e0abf3cc8651b0274e322c7 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sat, 5 Dec 2015 20:41:13 +0000
Subject: [PATCH 041/113] Begin refactoring the builder code into methods

This moves most of the 'convert this time zone into a list of timespans' code to a new Builder type.

The refactoring isn't yet complete, hopefully obviously, but it's at a stable point when it compiles and the data crate output is not modified.

It highlights how many of the variables being changed on each iteration are only important for one or the other Saving variant. It also combines the code for the NoSaving and Fixed variants, as they differed only by one variable.

Next steps include fixing some of the warnings and getting rid of more per-iteration variables.
---
 src/transitions.rs | 255 +++++++++++++++++++++++----------------------
 1 file changed, 132 insertions(+), 123 deletions(-)

diff --git a/src/transitions.rs b/src/transitions.rs
index 8c761ae..52a87fb 100644
--- a/src/transitions.rs
+++ b/src/transitions.rs
@@ -101,7 +101,7 @@
 //! The logic in this file is based off of `zic.c`, which comes with the
 //! zoneinfo files and is in the public domain.
 
-use table::{Table, Saving};
+use table::{Table, Saving, RuleInfo, ZoneInfo};
 use datetime::LocalDateTime;
 
 
@@ -157,7 +157,6 @@ impl FixedTimespan {
 /// Trait to put the `timespans` method on Tables.
 pub trait TableTransitions {
 
-    /// The
     fn timespans(&self, zone_name: &str) -> FixedTimespanSet;
 }
 
@@ -166,168 +165,179 @@ impl TableTransitions for Table {
 
     /// Computes a fixed timespan set for the timezone with the given name.
     fn timespans(&self, zone_name: &str) -> FixedTimespanSet {
-        let mut transitions = Vec::new();
-        let mut start_time = None;
-        let mut until_time = None;
-
-        let mut first_transition = None;
+        let mut builder = FixedTimespanSetBuilder::default();
 
         let zoneset = self.get_zoneset(zone_name);
-        for (i, timespan) in zoneset.iter().enumerate() {
+        for (i, zone_info) in zoneset.iter().enumerate() {
             let mut dst_offset = 0;
             let use_until      = i != zoneset.len() - 1;
-            let utc_offset     = timespan.offset;
+            let utc_offset     = zone_info.offset;
 
             let mut insert_start_transition = i > 0;
             let mut start_zone_id = None;
-            let mut start_utc_offset = timespan.offset;
+            let mut start_utc_offset = zone_info.offset;
             let mut start_dst_offset = 0;
 
-            match timespan.saving {
+            match zone_info.saving {
                 Saving::NoSaving => {
-                    dst_offset = 0;
-                    start_zone_id = Some(timespan.format.format_constant());
-
-                    if insert_start_transition {
-                        let t = (start_time.unwrap(), FixedTimespan {
-                            utc_offset: utc_offset,
-                            dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
-                        });
-                        transitions.push(t);
-                        insert_start_transition = false;
-                    }
-                    else {
-                        first_transition = Some(FixedTimespan {
-                            utc_offset: utc_offset,
-                            dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
-                        });
-                    }
+                    builder.add_fixed_saving(zone_info, 0, &mut dst_offset, use_until, utc_offset, &mut insert_start_transition, &mut start_zone_id, &mut start_utc_offset, &mut start_dst_offset);
                 },
 
                 Saving::OneOff(amount) => {
-                    dst_offset = amount;
-                    start_zone_id = Some(timespan.format.format_constant());
-
-                    if insert_start_transition {
-                        let t = (start_time.unwrap(), FixedTimespan {
-                            utc_offset: utc_offset,
-                            dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
-                        });
-                        transitions.push(t);
-                        insert_start_transition = false;
-                    }
-                    else {
-                        first_transition = Some(FixedTimespan {
-                            utc_offset: utc_offset,
-                            dst_offset: dst_offset,
-                            name:       start_zone_id.clone().unwrap_or("".to_owned()),
-                        });
-                    }
+                    builder.add_fixed_saving(zone_info, amount, &mut dst_offset, use_until, utc_offset, &mut insert_start_transition, &mut start_zone_id, &mut start_utc_offset, &mut start_dst_offset);
                 },
 
                 Saving::Multiple(ref rules) => {
-                    use datetime::DatePiece;
-
-                    for year in 1800..2100 {
-                        if use_until && year > LocalDateTime::at(timespan.end_time.unwrap().to_timestamp()).year() {
-                            break;
-                        }
-
-                        let mut activated_rules = self.rulesets[&*rules].iter()
-                                                      .filter(|r| r.applies_to_year(year))
-                                                      .collect::<Vec<_>>();
-
-                        loop {
-                            if use_until {
-                                until_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - dst_offset);
-                            }
-
-                            // Find the minimum rule based on the current UTC and DST offsets.
-                            // (this can be replaced with min_by when it stabilises):
-                            //.min_by(|r| r.1.absolute_datetime(year, utc_offset, dst_offset));
-                            let pos = {
-                                let earliest = activated_rules.iter().enumerate()
-                                    .map(|(i, r)| (r.absolute_datetime(year, utc_offset, dst_offset), i))
-                                    .min()
-                                    .map(|(_, i)| i);
-
-                                match earliest {
-                                    Some(p) => p,
-                                    None    => break,
-                                }
-                            };
-
-                            let earliest_rule = activated_rules.remove(pos);
-                            let earliest_at = earliest_rule.absolute_datetime(year, utc_offset, dst_offset).to_instant().seconds();
-
-                            if use_until && earliest_at >= until_time.unwrap() {
-                                break;
-                            }
-
-                            dst_offset = earliest_rule.time_to_add;
-
-                            if insert_start_transition && earliest_at == start_time.unwrap() {
-                                insert_start_transition = false;
-                            }
-
-                            if insert_start_transition {
-                                if earliest_at < start_time.unwrap() {
-                                    start_utc_offset = timespan.offset;
-                                    start_dst_offset = dst_offset;
-                                    start_zone_id = Some(timespan.format.format(dst_offset, earliest_rule.letters.as_ref()));
-                                    continue;
-                                }
-
-                                if start_zone_id.is_none() && start_utc_offset + start_dst_offset == timespan.offset + dst_offset {
-                                    start_zone_id = Some(timespan.format.format(dst_offset, earliest_rule.letters.as_ref()));
-                                }
-                            }
-
-                            let t = (earliest_at, FixedTimespan {
-                                utc_offset: timespan.offset,
-                                dst_offset: earliest_rule.time_to_add,
-                                name:       timespan.format.format(earliest_rule.time_to_add, earliest_rule.letters.as_ref()),
-                            });
-                            transitions.push(t);
-                        }
-                    }
+                    let rules = &self.rulesets[&*rules];
+                    builder.add_multiple_saving(zone_info, &*rules, &mut dst_offset, use_until, utc_offset, &mut insert_start_transition, &mut start_zone_id, &mut start_utc_offset, &mut start_dst_offset);
                 }
             }
 
             if insert_start_transition && start_zone_id.is_some() {
-                let t = (start_time.expect("Start time"), FixedTimespan {
+                let t = (builder.start_time.expect("Start time"), FixedTimespan {
                     utc_offset: start_utc_offset,
                     dst_offset: start_dst_offset,
                     name:       start_zone_id.clone().expect("Start zone ID"),
                 });
-                transitions.push(t);
+                builder.rest.push(t);
             }
 
             if use_until {
-                start_time = Some(timespan.end_time.expect("End time").to_timestamp() - utc_offset - dst_offset);
+                builder.start_time = Some(zone_info.end_time.expect("End time").to_timestamp() - utc_offset - dst_offset);
             }
         }
 
-        transitions.sort_by(|a, b| a.0.cmp(&b.0));
+        builder.build()
+    }
+}
+
+#[derive(Debug, Default)]
+struct FixedTimespanSetBuilder {
+    first: Option<FixedTimespan>,
+    rest: Vec<(i64, FixedTimespan)>,
+
+    start_time: Option<i64>,
+    until_time: Option<i64>,
+}
+
+impl FixedTimespanSetBuilder {
+    fn add_fixed_saving(&mut self, timespan: &ZoneInfo, amount: i64,
+            dst_offset: &mut i64, use_until: bool, utc_offset: i64, insert_start_transition: &mut bool,
+            start_zone_id: &mut Option<String>, start_utc_offset: &mut i64, start_dst_offset: &mut i64)
+    {
+        *dst_offset = amount;
+        *start_zone_id = Some(timespan.format.format_constant());
+
+        if *insert_start_transition {
+            let time = self.start_time.unwrap();
+            let timespan = FixedTimespan {
+                utc_offset: timespan.offset,
+                dst_offset: *dst_offset,
+                name:       start_zone_id.clone().unwrap_or("".to_owned()),
+            };
+
+            self.rest.push((time, timespan));
+            *insert_start_transition = false;
+        }
+        else {
+            self.first = Some(FixedTimespan {
+                utc_offset: utc_offset,
+                dst_offset: *dst_offset,
+                name:       start_zone_id.clone().unwrap_or("".to_owned()),
+            });
+        }
+    }
+
+    fn add_multiple_saving(&mut self, timespan: &ZoneInfo, rules: &[RuleInfo],
+            dst_offset: &mut i64, use_until: bool, utc_offset: i64, insert_start_transition: &mut bool,
+            start_zone_id: &mut Option<String>, start_utc_offset: &mut i64, start_dst_offset: &mut i64)
+    {
+        use std::mem::replace;
+        use datetime::DatePiece;
 
-        let first = match first_transition {
+        for year in 1800..2100 {
+            if use_until && year > LocalDateTime::at(timespan.end_time.unwrap().to_timestamp()).year() {
+                break;
+            }
+
+            let mut activated_rules = rules.iter()
+                                           .filter(|r| r.applies_to_year(year))
+                                           .collect::<Vec<_>>();
+
+            loop {
+                if use_until {
+                    self.until_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - *dst_offset);
+                }
+
+                // Find the minimum rule based on the current UTC and DST offsets.
+                // (this can be replaced with min_by when it stabilises):
+                //.min_by(|r| r.1.absolute_datetime(year, utc_offset, dst_offset));
+                let pos = {
+                    let earliest = activated_rules.iter().enumerate()
+                        .map(|(i, r)| (r.absolute_datetime(year, utc_offset, *dst_offset), i))
+                        .min()
+                        .map(|(_, i)| i);
+
+                    match earliest {
+                        Some(p) => p,
+                        None    => break,
+                    }
+                };
+
+                let earliest_rule = activated_rules.remove(pos);
+                let earliest_at = earliest_rule.absolute_datetime(year, utc_offset, *dst_offset).to_instant().seconds();
+
+                if use_until && earliest_at >= self.until_time.unwrap() {
+                    break;
+                }
+
+                *dst_offset = earliest_rule.time_to_add;
+
+                if *insert_start_transition && earliest_at == self.start_time.unwrap() {
+                    *insert_start_transition = false;
+                }
+
+                if *insert_start_transition {
+                    if earliest_at < self.start_time.unwrap() {
+                        replace(start_utc_offset, timespan.offset);
+                        replace(start_dst_offset, *dst_offset);
+                        replace(start_zone_id, Some(timespan.format.format(*dst_offset, earliest_rule.letters.as_ref())));
+                        continue;
+                    }
+
+                    if start_zone_id.is_none() && *start_utc_offset + *start_dst_offset == timespan.offset + *dst_offset {
+                        replace(start_zone_id, Some(timespan.format.format(*dst_offset, earliest_rule.letters.as_ref())));
+                    }
+                }
+
+                let t = (earliest_at, FixedTimespan {
+                    utc_offset: timespan.offset,
+                    dst_offset: earliest_rule.time_to_add,
+                    name:       timespan.format.format(earliest_rule.time_to_add, earliest_rule.letters.as_ref()),
+                });
+                self.rest.push(t);
+            }
+        }
+
+    }
+
+    fn build(mut self) -> FixedTimespanSet {
+        self.rest.sort_by(|a, b| a.0.cmp(&b.0));
+
+        let first = match self.first {
             Some(ft) => ft,
-            None     => transitions.iter().find(|t| t.1.dst_offset == 0).unwrap().1.clone(),
+            None     => self.rest.iter().find(|t| t.1.dst_offset == 0).unwrap().1.clone(),
         };
 
         let mut zoneset = FixedTimespanSet {
             first: first,
-            rest:  transitions,
+            rest:  self.rest,
         };
         optimise(&mut zoneset);
         zoneset
     }
 }
 
-
 #[allow(unused_results)]  // for remove
 fn optimise(transitions: &mut FixedTimespanSet) {
     let mut from_i = 0;
@@ -360,7 +370,6 @@ fn optimise(transitions: &mut FixedTimespanSet) {
 }
 
 
-
 #[cfg(test)]
 mod test {
     use super::*;

From aca6899322239b20896ccfb41e4f0ff339be08f1 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sat, 5 Dec 2015 20:43:14 +0000
Subject: [PATCH 042/113] Remove unused variables around fixed-offset spans

---
 src/transitions.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/transitions.rs b/src/transitions.rs
index 52a87fb..19b7014 100644
--- a/src/transitions.rs
+++ b/src/transitions.rs
@@ -180,11 +180,11 @@ impl TableTransitions for Table {
 
             match zone_info.saving {
                 Saving::NoSaving => {
-                    builder.add_fixed_saving(zone_info, 0, &mut dst_offset, use_until, utc_offset, &mut insert_start_transition, &mut start_zone_id, &mut start_utc_offset, &mut start_dst_offset);
+                    builder.add_fixed_saving(zone_info, 0, &mut dst_offset, utc_offset, &mut insert_start_transition, &mut start_zone_id);
                 },
 
                 Saving::OneOff(amount) => {
-                    builder.add_fixed_saving(zone_info, amount, &mut dst_offset, use_until, utc_offset, &mut insert_start_transition, &mut start_zone_id, &mut start_utc_offset, &mut start_dst_offset);
+                    builder.add_fixed_saving(zone_info, amount, &mut dst_offset, utc_offset, &mut insert_start_transition, &mut start_zone_id);
                 },
 
                 Saving::Multiple(ref rules) => {
@@ -222,8 +222,8 @@ struct FixedTimespanSetBuilder {
 
 impl FixedTimespanSetBuilder {
     fn add_fixed_saving(&mut self, timespan: &ZoneInfo, amount: i64,
-            dst_offset: &mut i64, use_until: bool, utc_offset: i64, insert_start_transition: &mut bool,
-            start_zone_id: &mut Option<String>, start_utc_offset: &mut i64, start_dst_offset: &mut i64)
+            dst_offset: &mut i64, utc_offset: i64, insert_start_transition: &mut bool,
+            start_zone_id: &mut Option<String>)
     {
         *dst_offset = amount;
         *start_zone_id = Some(timespan.format.format_constant());

From f0af1d7456a279257f0a5c71cc2bb68fa7158820 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 11 Feb 2016 18:05:06 +0000
Subject: [PATCH 043/113] Move data crate builder to its own crate

---
 Cargo.toml                                      |  4 ----
 data-crate-builder/Cargo.toml                   | 17 +++++++++++++++++
 {bin => data-crate-builder}/build-data-crate.rs |  0
 3 files changed, 17 insertions(+), 4 deletions(-)
 create mode 100644 data-crate-builder/Cargo.toml
 rename {bin => data-crate-builder}/build-data-crate.rs (100%)

diff --git a/Cargo.toml b/Cargo.toml
index f94f634..4283c6b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,10 +3,6 @@ name = "zoneinfo_parse"
 version = "0.1.0"
 authors = ["Ben S <ogham@bsago.me>"]
 
-[[bin]]
-name = "build-data-crate"
-path = "bin/build-data-crate.rs"
-
 [dependencies]
 lazy_static = "*"
 regex = "*"
diff --git a/data-crate-builder/Cargo.toml b/data-crate-builder/Cargo.toml
new file mode 100644
index 0000000..74112ca
--- /dev/null
+++ b/data-crate-builder/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "build-data-crate"
+version = "0.1.0"
+authors = ["Ben S <ogham@bsago.me>"]
+
+[[bin]]
+name = "build-data-crate"
+path = "build-data-crate.rs"
+
+[dependencies]
+getopts = "0.2"
+
+[dependencies.zoneinfo_parse]
+path = ".."
+
+[dependencies.datetime]
+git = "https://github.com/rust-datetime/datetime.git"
diff --git a/bin/build-data-crate.rs b/data-crate-builder/build-data-crate.rs
similarity index 100%
rename from bin/build-data-crate.rs
rename to data-crate-builder/build-data-crate.rs

From a3ede4a008a9080fcbc8588e7275696f00901031 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 11 Feb 2016 18:37:54 +0000
Subject: [PATCH 044/113] Use getopts crate for better parsing

---
 data-crate-builder/build-data-crate.rs | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/data-crate-builder/build-data-crate.rs b/data-crate-builder/build-data-crate.rs
index 9ff0fb9..178811e 100644
--- a/data-crate-builder/build-data-crate.rs
+++ b/data-crate-builder/build-data-crate.rs
@@ -7,6 +7,8 @@ use std::fs::{File, OpenOptions, create_dir, metadata};
 use std::path::{Path, PathBuf};
 use std::process::exit;
 
+extern crate getopts;
+
 extern crate datetime;
 use datetime::{LocalDateTime, ISO};
 
@@ -18,9 +20,19 @@ use zoneinfo_parse::transitions::{TableTransitions};
 
 
 fn main() {
+    let mut opts = getopts::Options::new();
+    opts.reqopt("o", "output", "directory to write the crate into", "DIR");
+
     let args: Vec<_> = args().skip(1).collect();
+    let matches = match opts.parse(&args) {
+        Ok(m)  => m,
+        Err(e) => {
+            println!("Error parsing options: {}", e);
+            exit(1);
+        },
+    };
 
-    let data_crate = match DataCrate::new(&args[0], &args[1..]) {
+    let data_crate = match DataCrate::new(matches.opt_str("output").unwrap(), &matches.free) {
         Ok(dc) => dc,
         Err(errs) => {
             for err in errs {

From 4a832e3ae93fbe605de5ee7ab5f22b1aec0a16ff Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Thu, 11 Feb 2016 18:47:14 +0000
Subject: [PATCH 045/113] We needn't collect the args before using them

---
 data-crate-builder/build-data-crate.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/data-crate-builder/build-data-crate.rs b/data-crate-builder/build-data-crate.rs
index 178811e..ba990e8 100644
--- a/data-crate-builder/build-data-crate.rs
+++ b/data-crate-builder/build-data-crate.rs
@@ -1,4 +1,4 @@
-use std::env::args;
+use std::env::args_os;
 use std::error::Error as ErrorTrait;
 use std::io::prelude::*;
 use std::io::BufReader;
@@ -23,8 +23,7 @@ fn main() {
     let mut opts = getopts::Options::new();
     opts.reqopt("o", "output", "directory to write the crate into", "DIR");
 
-    let args: Vec<_> = args().skip(1).collect();
-    let matches = match opts.parse(&args) {
+    let matches = match opts.parse(args_os().skip(1)) {
         Ok(m)  => m,
         Err(e) => {
             println!("Error parsing options: {}", e);

From 0e42837849464b456af3fd29dfd91521760203d9 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 13:00:08 +0000
Subject: [PATCH 046/113] Log errors to stderr, not stdout

---
 data-crate-builder/build-data-crate.rs | 12 +++++++-----
 data-crate-builder/util.rs             |  8 ++++++++
 2 files changed, 15 insertions(+), 5 deletions(-)
 create mode 100644 data-crate-builder/util.rs

diff --git a/data-crate-builder/build-data-crate.rs b/data-crate-builder/build-data-crate.rs
index ba990e8..34fd15e 100644
--- a/data-crate-builder/build-data-crate.rs
+++ b/data-crate-builder/build-data-crate.rs
@@ -1,7 +1,7 @@
 use std::env::args_os;
 use std::error::Error as ErrorTrait;
-use std::io::prelude::*;
-use std::io::BufReader;
+use std::io::{Read, BufRead, BufReader};
+use std::io::{Write, stderr};
 use std::io::Result as IOResult;
 use std::fs::{File, OpenOptions, create_dir, metadata};
 use std::path::{Path, PathBuf};
@@ -18,6 +18,8 @@ use zoneinfo_parse::table::{Table, TableBuilder};
 use zoneinfo_parse::structure::{Structure, Child};
 use zoneinfo_parse::transitions::{TableTransitions};
 
+#[macro_use]
+mod util;
 
 fn main() {
     let mut opts = getopts::Options::new();
@@ -26,7 +28,7 @@ fn main() {
     let matches = match opts.parse(args_os().skip(1)) {
         Ok(m)  => m,
         Err(e) => {
-            println!("Error parsing options: {}", e);
+            println_stderr!("Error parsing options: {}", e);
             exit(1);
         },
     };
@@ -38,7 +40,7 @@ fn main() {
                 println!("{}:{}: {}", err.filename, err.line, err.error);
             }
 
-            println!("Errors occurred - not going any further.");
+            println_stderr!("Errors occurred - not going any further.");
             exit(1);
         },
     };
@@ -46,7 +48,7 @@ fn main() {
     match data_crate.run() {
         Ok(()) => println!("All done."),
         Err(e) => {
-            println!("IO error: {}", e);
+            println_stderr!("IO error: {}", e);
             exit(1);
         },
     }
diff --git a/data-crate-builder/util.rs b/data-crate-builder/util.rs
new file mode 100644
index 0000000..8b4324e
--- /dev/null
+++ b/data-crate-builder/util.rs
@@ -0,0 +1,8 @@
+#[macro_export]
+macro_rules! println_stderr {
+    ($($arg:tt)*) => (
+        if let Err(x) = writeln!(&mut stderr(), $($arg)* ) {
+            panic!("Unable to write to stderr: {}", x);
+        }
+    )
+}

From 6dd1606240af3de33af5472cd696b16948f7590e Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 13:20:32 +0000
Subject: [PATCH 047/113] Replace calls to exit with early return

---
 data-crate-builder/build-data-crate.rs | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/data-crate-builder/build-data-crate.rs b/data-crate-builder/build-data-crate.rs
index 34fd15e..f660661 100644
--- a/data-crate-builder/build-data-crate.rs
+++ b/data-crate-builder/build-data-crate.rs
@@ -22,6 +22,12 @@ use zoneinfo_parse::transitions::{TableTransitions};
 mod util;
 
 fn main() {
+    if let Err(()) = build_data_crate() {
+        exit(1);
+    }
+}
+
+fn build_data_crate() -> Result<(), ()> {
     let mut opts = getopts::Options::new();
     opts.reqopt("o", "output", "directory to write the crate into", "DIR");
 
@@ -29,7 +35,7 @@ fn main() {
         Ok(m)  => m,
         Err(e) => {
             println_stderr!("Error parsing options: {}", e);
-            exit(1);
+            return Err(());
         },
     };
 
@@ -37,11 +43,11 @@ fn main() {
         Ok(dc) => dc,
         Err(errs) => {
             for err in errs {
-                println!("{}:{}: {}", err.filename, err.line, err.error);
+                println_stderr!("{}:{}: {}", err.filename, err.line, err.error);
             }
 
             println_stderr!("Errors occurred - not going any further.");
-            exit(1);
+            return Err(());
         },
     };
 
@@ -49,9 +55,11 @@ fn main() {
         Ok(()) => println!("All done."),
         Err(e) => {
             println_stderr!("IO error: {}", e);
-            exit(1);
+            return Err(());
         },
     }
+
+    Ok(())
 }
 
 struct DataCrate {

From 296a5f2c189f9161f6e6c86545fa2e71d6923f84 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 14:08:21 +0000
Subject: [PATCH 048/113] Use quick-error to simplify error types

---
 data-crate-builder/Cargo.toml          |  1 +
 data-crate-builder/build-data-crate.rs | 87 ++++++++++++++++----------
 2 files changed, 54 insertions(+), 34 deletions(-)

diff --git a/data-crate-builder/Cargo.toml b/data-crate-builder/Cargo.toml
index 74112ca..f62b27a 100644
--- a/data-crate-builder/Cargo.toml
+++ b/data-crate-builder/Cargo.toml
@@ -9,6 +9,7 @@ path = "build-data-crate.rs"
 
 [dependencies]
 getopts = "0.2"
+quick-error = "0.2"
 
 [dependencies.zoneinfo_parse]
 path = ".."
diff --git a/data-crate-builder/build-data-crate.rs b/data-crate-builder/build-data-crate.rs
index f660661..8ad7629 100644
--- a/data-crate-builder/build-data-crate.rs
+++ b/data-crate-builder/build-data-crate.rs
@@ -1,8 +1,10 @@
 use std::env::args_os;
 use std::error::Error as ErrorTrait;
+use std::fmt;
 use std::io::{Read, BufRead, BufReader};
 use std::io::{Write, stderr};
 use std::io::Result as IOResult;
+use std::io::Error as IOError;
 use std::fs::{File, OpenOptions, create_dir, metadata};
 use std::path::{Path, PathBuf};
 use std::process::exit;
@@ -18,47 +20,29 @@ use zoneinfo_parse::table::{Table, TableBuilder};
 use zoneinfo_parse::structure::{Structure, Child};
 use zoneinfo_parse::transitions::{TableTransitions};
 
+#[macro_use]
+extern crate quick_error;
+
 #[macro_use]
 mod util;
 
+
 fn main() {
-    if let Err(()) = build_data_crate() {
+    if let Err(e) = build_data_crate() {
+        println_stderr!("{}", e);
         exit(1);
     }
 }
 
-fn build_data_crate() -> Result<(), ()> {
+fn build_data_crate() -> Result<(), SomeError> {
     let mut opts = getopts::Options::new();
     opts.reqopt("o", "output", "directory to write the crate into", "DIR");
 
-    let matches = match opts.parse(args_os().skip(1)) {
-        Ok(m)  => m,
-        Err(e) => {
-            println_stderr!("Error parsing options: {}", e);
-            return Err(());
-        },
-    };
-
-    let data_crate = match DataCrate::new(matches.opt_str("output").unwrap(), &matches.free) {
-        Ok(dc) => dc,
-        Err(errs) => {
-            for err in errs {
-                println_stderr!("{}:{}: {}", err.filename, err.line, err.error);
-            }
-
-            println_stderr!("Errors occurred - not going any further.");
-            return Err(());
-        },
-    };
-
-    match data_crate.run() {
-        Ok(()) => println!("All done."),
-        Err(e) => {
-            println_stderr!("IO error: {}", e);
-            return Err(());
-        },
-    }
+    let matches = try!(opts.parse(args_os().skip(1)));
+    let data_crate = try!(DataCrate::new(matches.opt_str("output").unwrap(), &matches.free));
+    try!(data_crate.run());
 
+    println!("All done.");
     Ok(())
 }
 
@@ -67,9 +51,31 @@ struct DataCrate {
     table: Table,
 }
 
+
+quick_error! {
+    #[derive(Debug)]
+    enum SomeError {
+        IO(err: IOError) {
+            from()
+            display(x) -> ("IO error: {}", err)
+        }
+
+        Errors(errs: Errors) {
+            from()
+            display(x) -> ("{}", errs)
+        }
+
+        Getopts(err: getopts::Fail) {
+            from()
+            display(x) -> ("Error parsing options: {}", err)
+        }
+    }
+}
+
+
 impl DataCrate {
 
-    fn new<P>(base_path: P, input_file_paths: &[String]) -> Result<DataCrate, Vec<Error>>
+    fn new<P>(base_path: P, input_file_paths: &[String]) -> Result<DataCrate, Errors>
     where P: Into<PathBuf> {
 
         let mut builder = TableBuilder::new();
@@ -92,7 +98,7 @@ impl DataCrate {
 
                     // If there’s an error, then display which line failed to parse.
                     Err(e) => {
-                        let error = Error {
+                        let error = ParseError {
                             filename: arg.clone(),
                             line: line_number + 1,
                             error: e.description().to_owned(),
@@ -112,7 +118,7 @@ impl DataCrate {
                 };
 
                 if let Err(e) = result {
-                    let error = Error {
+                    let error = ParseError {
                         filename: arg.clone(),
                         line: line_number + 1,
                         error: e.description().to_owned(),
@@ -130,7 +136,7 @@ impl DataCrate {
             })
         }
         else {
-            Err(errors)
+            Err(Errors(errors))
         }
     }
 
@@ -250,12 +256,25 @@ fn sanitise_name(name: &str) -> String {
     name.replace("-", "_")
 }
 
-struct Error {
+#[derive(Debug)]
+struct ParseError {
     filename: String,
     line: usize,
     error: String,
 }
 
+#[derive(Debug)]
+struct Errors(Vec<ParseError>);
+
+impl fmt::Display for Errors {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        for err in &self.0 {
+            try!(write!(f, "{}:{}: {}\n", err.filename, err.line, err.error));
+        }
+        Ok(())
+    }
+}
+
 const WARNING_HEADER: &'static str = r##"
 // ------
 // This file is autogenerated!

From fe0ab4076865e72ab065d46cf35efeabecd1a693 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 14:16:07 +0000
Subject: [PATCH 049/113] unwrap -> try

---
 data-crate-builder/build-data-crate.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/data-crate-builder/build-data-crate.rs b/data-crate-builder/build-data-crate.rs
index 8ad7629..78af6f9 100644
--- a/data-crate-builder/build-data-crate.rs
+++ b/data-crate-builder/build-data-crate.rs
@@ -34,7 +34,7 @@ fn main() {
     }
 }
 
-fn build_data_crate() -> Result<(), SomeError> {
+fn build_data_crate() -> Result<(), Error> {
     let mut opts = getopts::Options::new();
     opts.reqopt("o", "output", "directory to write the crate into", "DIR");
 
@@ -54,7 +54,7 @@ struct DataCrate {
 
 quick_error! {
     #[derive(Debug)]
-    enum SomeError {
+    enum Error {
         IO(err: IOError) {
             from()
             display(x) -> ("IO error: {}", err)
@@ -75,14 +75,14 @@ quick_error! {
 
 impl DataCrate {
 
-    fn new<P>(base_path: P, input_file_paths: &[String]) -> Result<DataCrate, Errors>
+    fn new<P>(base_path: P, input_file_paths: &[String]) -> Result<DataCrate, Error>
     where P: Into<PathBuf> {
 
         let mut builder = TableBuilder::new();
         let mut errors = Vec::new();
 
         for arg in input_file_paths {
-            let f = File::open(arg).unwrap();
+            let f = try!(File::open(arg));
             let reader = BufReader::new(f);
 
             for (line_number, line) in reader.lines().enumerate() {
@@ -136,7 +136,7 @@ impl DataCrate {
             })
         }
         else {
-            Err(Errors(errors))
+            Err(Errors(errors).into())
         }
     }
 

From f97105f78c035f30c44bf20d47f789139cbafc74 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 14:21:07 +0000
Subject: [PATCH 050/113] Move Errors constructor somewhat

---
 data-crate-builder/build-data-crate.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/data-crate-builder/build-data-crate.rs b/data-crate-builder/build-data-crate.rs
index 78af6f9..2a4dd6c 100644
--- a/data-crate-builder/build-data-crate.rs
+++ b/data-crate-builder/build-data-crate.rs
@@ -61,7 +61,7 @@ quick_error! {
         }
 
         Errors(errs: Errors) {
-            from()
+            from(es: Vec<ParseError>) -> (Errors(es))
             display(x) -> ("{}", errs)
         }
 
@@ -136,7 +136,7 @@ impl DataCrate {
             })
         }
         else {
-            Err(Errors(errors).into())
+            Err(errors.into())
         }
     }
 

From d7acbdc60be034d79f474f5a1572bee962482d57 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 14:47:59 +0000
Subject: [PATCH 051/113] Split up into multiple files

---
 data-crate-builder/Cargo.toml                 |  2 +-
 .../data_crate.rs}                            | 81 ++-----------------
 data-crate-builder/src/errors.rs              | 45 +++++++++++
 data-crate-builder/src/main.rs                | 41 ++++++++++
 data-crate-builder/{ => src}/util.rs          |  0
 5 files changed, 92 insertions(+), 77 deletions(-)
 rename data-crate-builder/{build-data-crate.rs => src/data_crate.rs} (82%)
 create mode 100644 data-crate-builder/src/errors.rs
 create mode 100644 data-crate-builder/src/main.rs
 rename data-crate-builder/{ => src}/util.rs (100%)

diff --git a/data-crate-builder/Cargo.toml b/data-crate-builder/Cargo.toml
index f62b27a..7d717c5 100644
--- a/data-crate-builder/Cargo.toml
+++ b/data-crate-builder/Cargo.toml
@@ -5,7 +5,7 @@ authors = ["Ben S <ogham@bsago.me>"]
 
 [[bin]]
 name = "build-data-crate"
-path = "build-data-crate.rs"
+path = "src/main.rs"
 
 [dependencies]
 getopts = "0.2"
diff --git a/data-crate-builder/build-data-crate.rs b/data-crate-builder/src/data_crate.rs
similarity index 82%
rename from data-crate-builder/build-data-crate.rs
rename to data-crate-builder/src/data_crate.rs
index 2a4dd6c..30f73aa 100644
--- a/data-crate-builder/build-data-crate.rs
+++ b/data-crate-builder/src/data_crate.rs
@@ -1,81 +1,28 @@
-use std::env::args_os;
 use std::error::Error as ErrorTrait;
-use std::fmt;
 use std::io::{Read, BufRead, BufReader};
-use std::io::{Write, stderr};
+use std::io::Write;
 use std::io::Result as IOResult;
-use std::io::Error as IOError;
 use std::fs::{File, OpenOptions, create_dir, metadata};
 use std::path::{Path, PathBuf};
-use std::process::exit;
 
-extern crate getopts;
-
-extern crate datetime;
 use datetime::{LocalDateTime, ISO};
 
-extern crate zoneinfo_parse;
 use zoneinfo_parse::line::{Line};
 use zoneinfo_parse::table::{Table, TableBuilder};
 use zoneinfo_parse::structure::{Structure, Child};
 use zoneinfo_parse::transitions::{TableTransitions};
 
-#[macro_use]
-extern crate quick_error;
-
-#[macro_use]
-mod util;
-
-
-fn main() {
-    if let Err(e) = build_data_crate() {
-        println_stderr!("{}", e);
-        exit(1);
-    }
-}
-
-fn build_data_crate() -> Result<(), Error> {
-    let mut opts = getopts::Options::new();
-    opts.reqopt("o", "output", "directory to write the crate into", "DIR");
+use errors::{Error, ParseError};
 
-    let matches = try!(opts.parse(args_os().skip(1)));
-    let data_crate = try!(DataCrate::new(matches.opt_str("output").unwrap(), &matches.free));
-    try!(data_crate.run());
-
-    println!("All done.");
-    Ok(())
-}
-
-struct DataCrate {
+pub struct DataCrate {
     base_path: PathBuf,
     table: Table,
 }
 
 
-quick_error! {
-    #[derive(Debug)]
-    enum Error {
-        IO(err: IOError) {
-            from()
-            display(x) -> ("IO error: {}", err)
-        }
-
-        Errors(errs: Errors) {
-            from(es: Vec<ParseError>) -> (Errors(es))
-            display(x) -> ("{}", errs)
-        }
-
-        Getopts(err: getopts::Fail) {
-            from()
-            display(x) -> ("Error parsing options: {}", err)
-        }
-    }
-}
-
-
 impl DataCrate {
 
-    fn new<P>(base_path: P, input_file_paths: &[String]) -> Result<DataCrate, Error>
+    pub fn new<P>(base_path: P, input_file_paths: &[String]) -> Result<DataCrate, Error>
     where P: Into<PathBuf> {
 
         let mut builder = TableBuilder::new();
@@ -140,7 +87,7 @@ impl DataCrate {
         }
     }
 
-    fn run(&self) -> IOResult<()> {
+    pub fn run(&self) -> IOResult<()> {
         try!(self.create_structure_directories());
         try!(self.write_zonesets());
         Ok(())
@@ -256,24 +203,6 @@ fn sanitise_name(name: &str) -> String {
     name.replace("-", "_")
 }
 
-#[derive(Debug)]
-struct ParseError {
-    filename: String,
-    line: usize,
-    error: String,
-}
-
-#[derive(Debug)]
-struct Errors(Vec<ParseError>);
-
-impl fmt::Display for Errors {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        for err in &self.0 {
-            try!(write!(f, "{}:{}: {}\n", err.filename, err.line, err.error));
-        }
-        Ok(())
-    }
-}
 
 const WARNING_HEADER: &'static str = r##"
 // ------
diff --git a/data-crate-builder/src/errors.rs b/data-crate-builder/src/errors.rs
new file mode 100644
index 0000000..3307024
--- /dev/null
+++ b/data-crate-builder/src/errors.rs
@@ -0,0 +1,45 @@
+use std::fmt;
+use std::io::Error as IOError;
+
+use getopts;
+
+
+quick_error! {
+    #[derive(Debug)]
+    pub enum Error {
+        IO(err: IOError) {
+            from()
+            display(x) -> ("IO error: {}", err)
+        }
+
+        Errors(errs: Errors) {
+            from(es: Vec<ParseError>) -> (Errors(es))
+            display(x) -> ("{}", errs)
+        }
+
+        Getopts(err: getopts::Fail) {
+            from()
+            display(x) -> ("Error parsing options: {}", err)
+        }
+    }
+}
+
+
+#[derive(Debug)]
+pub struct ParseError {
+    pub filename: String,
+    pub line: usize,
+    pub error: String,
+}
+
+#[derive(Debug)]
+pub struct Errors(Vec<ParseError>);
+
+impl fmt::Display for Errors {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        for err in &self.0 {
+            try!(write!(f, "{}:{}: {}\n", err.filename, err.line, err.error));
+        }
+        Ok(())
+    }
+}
\ No newline at end of file
diff --git a/data-crate-builder/src/main.rs b/data-crate-builder/src/main.rs
new file mode 100644
index 0000000..10c589d
--- /dev/null
+++ b/data-crate-builder/src/main.rs
@@ -0,0 +1,41 @@
+use std::env::args_os;
+use std::io::{Write, stderr};
+use std::process::exit;
+
+extern crate getopts;
+
+extern crate datetime;
+
+extern crate zoneinfo_parse;
+
+#[macro_use]
+extern crate quick_error;
+
+mod data_crate;
+use data_crate::DataCrate;
+
+mod errors;
+use errors::Error;
+
+#[macro_use]
+mod util;
+
+
+fn main() {
+    if let Err(e) = build_data_crate() {
+        println_stderr!("{}", e);
+        exit(1);
+    }
+}
+
+fn build_data_crate() -> Result<(), Error> {
+    let mut opts = getopts::Options::new();
+    opts.reqopt("o", "output", "directory to write the crate into", "DIR");
+
+    let matches = try!(opts.parse(args_os().skip(1)));
+    let data_crate = try!(DataCrate::new(matches.opt_str("output").unwrap(), &matches.free));
+    try!(data_crate.run());
+
+    println!("All done.");
+    Ok(())
+}
diff --git a/data-crate-builder/util.rs b/data-crate-builder/src/util.rs
similarity index 100%
rename from data-crate-builder/util.rs
rename to data-crate-builder/src/util.rs

From d28375e5d94ab4f3e386a22114aa247ae739d0a6 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 16:13:53 +0000
Subject: [PATCH 052/113] Spew comments everywhere

---
 data-crate-builder/src/data_crate.rs | 52 +++++++++++++++++++++-------
 data-crate-builder/src/errors.rs     | 20 ++++++++++-
 data-crate-builder/src/main.rs       |  2 --
 data-crate-builder/src/util.rs       |  5 +++
 4 files changed, 63 insertions(+), 16 deletions(-)

diff --git a/data-crate-builder/src/data_crate.rs b/data-crate-builder/src/data_crate.rs
index 30f73aa..82bebb7 100644
--- a/data-crate-builder/src/data_crate.rs
+++ b/data-crate-builder/src/data_crate.rs
@@ -1,9 +1,12 @@
+//! Creating the data crate from several input files, and the writing of Rust
+//! files afterwards.
+
 use std::error::Error as ErrorTrait;
 use std::io::{Read, BufRead, BufReader};
 use std::io::Write;
 use std::io::Result as IOResult;
-use std::fs::{File, OpenOptions, create_dir, metadata};
-use std::path::{Path, PathBuf};
+use std::fs::{File, OpenOptions, create_dir};
+use std::path::PathBuf;
 
 use datetime::{LocalDateTime, ISO};
 
@@ -14,14 +17,26 @@ use zoneinfo_parse::transitions::{TableTransitions};
 
 use errors::{Error, ParseError};
 
+
+/// The entire contents of some zoneinfo data files.
 pub struct DataCrate {
+
+    /// The base path to write the Rust files to.
     base_path: PathBuf,
+
+    /// The data to write.
     table: Table,
 }
 
-
 impl DataCrate {
 
+    /// Creates a new data crate based on the contents of several files,
+    /// returning an error if any of the files can’t be opened or any of the
+    /// lines doesn’t parse correctly. The resulting data crate value can then
+    /// be turned into many Rust files of time zone info.
+    ///
+    /// All the errors are stored and returned in one go, rather than
+    /// returning early after the first one.
     pub fn new<P>(base_path: P, input_file_paths: &[String]) -> Result<DataCrate, Error>
     where P: Into<PathBuf> {
 
@@ -76,6 +91,7 @@ impl DataCrate {
             }
         }
 
+        // If there are *any* errors, then we can’t return success.
         if errors.is_empty() {
             Ok(DataCrate {
                 base_path: base_path.into(),
@@ -87,15 +103,24 @@ impl DataCrate {
         }
     }
 
+    /// There are two steps to writing the data: creating the directories the
+    /// data goes in (and the `mod.rs` files for those directories), and then
+    /// creating the files inside those directories.
     pub fn run(&self) -> IOResult<()> {
         try!(self.create_structure_directories());
         try!(self.write_zonesets());
         Ok(())
     }
 
+    /// Creates the directories that the Rust files get written to later. Also
+    /// creates `mod.rs` files inside those directories.
     fn create_structure_directories(&self) -> IOResult<()> {
+        let mut open_opts = OpenOptions::new();
+        open_opts.write(true).create(true).truncate(true);
+
         let base_mod_path = self.base_path.join("mod.rs");
-        let mut base_w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(base_mod_path));
+        let mut base_w = try!(open_opts.open(base_mod_path));
+
         try!(writeln!(base_w, "{}", WARNING_HEADER));
         try!(writeln!(base_w, "{}", MOD_HEADER));
 
@@ -106,13 +131,13 @@ impl DataCrate {
 
             let components: PathBuf = entry.name.split('/').collect();
             let dir_path = self.base_path.join(components);
-            if !is_directory(&dir_path) {
+            if !dir_path.is_dir() {
                 println!("Creating directory {:?}", &dir_path);
                 try!(create_dir(&dir_path));
             }
 
             let mod_path = dir_path.join("mod.rs");
-            let mut w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(mod_path));
+            let mut w = try!(open_opts.open(mod_path));
             for child in &entry.children {
                 match *child {
                     Child::TimeZone(ref name) => {
@@ -151,6 +176,7 @@ impl DataCrate {
         Ok(())
     }
 
+    /// Writes each zone file as a Rust file.
     fn write_zonesets(&self) -> IOResult<()> {
         for name in self.table.zonesets.keys().chain(self.table.links.keys()) {
             let components: PathBuf = name.split('/').map(sanitise_name).collect();
@@ -192,18 +218,16 @@ impl DataCrate {
     }
 }
 
-fn is_directory(path: &Path) -> bool {
-    match metadata(path) {
-        Ok(m)  => m.is_dir(),
-        Err(_) => false,
-    }
-}
-
+/// Rust places constraints on what modules can be named, so we need to
+/// “sanitise” some of the time zone names before they can be made into
+/// modules.
 fn sanitise_name(name: &str) -> String {
     name.replace("-", "_")
 }
 
 
+/// The comment placed at the top of all autogenerated files, so they aren’t
+/// ever changed by a human and then overwritten by this program later.
 const WARNING_HEADER: &'static str = r##"
 // ------
 // This file is autogenerated!
@@ -211,11 +235,13 @@ const WARNING_HEADER: &'static str = r##"
 // ------
 "##;
 
+/// The imports needed for a zoneinfo Rust file.
 const ZONEINFO_HEADER: &'static str = r##"
 use std::borrow::Cow;
 use datetime::zone::{StaticTimeZone, FixedTimespanSet, FixedTimespan};
 "##;
 
+/// The imports needed for a `mod.rs` file.
 const MOD_HEADER: &'static str = r##"
 use datetime::zone::StaticTimeZone;
 "##;
diff --git a/data-crate-builder/src/errors.rs b/data-crate-builder/src/errors.rs
index 3307024..1d6bc18 100644
--- a/data-crate-builder/src/errors.rs
+++ b/data-crate-builder/src/errors.rs
@@ -1,22 +1,30 @@
+//! Any errors that can happen ever.
+
 use std::fmt;
 use std::io::Error as IOError;
 
 use getopts;
 
-
 quick_error! {
+
+    /// Anything that can go wrong at any stage in the program, causing it to
+    /// return 1 instead of 0.
     #[derive(Debug)]
     pub enum Error {
+
+        /// A file or directory couldn’t be read or written to.
         IO(err: IOError) {
             from()
             display(x) -> ("IO error: {}", err)
         }
 
+        /// The `zoneinfo-parse` crate didn’t like one or more lines of input.
         Errors(errs: Errors) {
             from(es: Vec<ParseError>) -> (Errors(es))
             display(x) -> ("{}", errs)
         }
 
+        /// The `getopts` crate didn’t like the user’s command-line args.
         Getopts(err: getopts::Fail) {
             from()
             display(x) -> ("Error parsing options: {}", err)
@@ -25,13 +33,23 @@ quick_error! {
 }
 
 
+/// An error when the data crate builder couldn’t parse a line of input.
 #[derive(Debug)]
 pub struct ParseError {
+
+    /// The filename that contained the line.
     pub filename: String,
+
+    /// The number of the line that failed to be parsed.
     pub line: usize,
+
+    /// A human-readable description of what the error was.
     pub error: String,
 }
 
+
+/// Wrapper around a vector of parse errors for a custom `fmt::Display`
+/// implementation used by the definition in `quick-error!` above.
 #[derive(Debug)]
 pub struct Errors(Vec<ParseError>);
 
diff --git a/data-crate-builder/src/main.rs b/data-crate-builder/src/main.rs
index 10c589d..3ebf11e 100644
--- a/data-crate-builder/src/main.rs
+++ b/data-crate-builder/src/main.rs
@@ -3,9 +3,7 @@ use std::io::{Write, stderr};
 use std::process::exit;
 
 extern crate getopts;
-
 extern crate datetime;
-
 extern crate zoneinfo_parse;
 
 #[macro_use]
diff --git a/data-crate-builder/src/util.rs b/data-crate-builder/src/util.rs
index 8b4324e..a1ff7a4 100644
--- a/data-crate-builder/src/util.rs
+++ b/data-crate-builder/src/util.rs
@@ -1,3 +1,8 @@
+//! Helpers and stuff.
+
+/// Helper macro that mimics `println!`, only it writes to stderr instead.
+///
+/// Stolen from http://stackoverflow.com/a/27590832
 #[macro_export]
 macro_rules! println_stderr {
     ($($arg:tt)*) => (

From 8f2fd39d3a105ebc0bb86caab0e3cbd99466324f Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 16:28:21 +0000
Subject: [PATCH 053/113] Add a sub-README

---
 data-crate-builder/README.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 data-crate-builder/README.md

diff --git a/data-crate-builder/README.md b/data-crate-builder/README.md
new file mode 100644
index 0000000..8d2a8e6
--- /dev/null
+++ b/data-crate-builder/README.md
@@ -0,0 +1,14 @@
+# Data crate builder
+
+This is a little program that reads the contents of one or more [zoneinfo files](https://github.com/eggert/tz) and outputs Rust code that contains parsed structs of the data within those files.
+
+It's used to create the [zoneinfo-data](https://github.com/rust-datetime/zoneinfo-data) crate, but can also be used to generate custom versions of that crate if you want to deal with your own time zone data.
+
+
+## Usage
+
+To build your own crate, run the program with the output directory as the `--option` argument, and the rest of the files as unnamed arguments. For example:
+
+    cargo run -- --output ~/my-crate ~/tz/africa ~/tz/antarctica ~/tz/asia ...
+
+This will place all the Rust code within `~/my-crate`. The directory will have to be created first.

From 62315f14deb2f123dae0be58f4e48fba0b661eea Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 18:03:00 +0000
Subject: [PATCH 054/113] Add a README

---
 README.md | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 64 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 13a9f7b..b80fb48 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,66 @@
 # zoneinfo-parse [![Build status](https://travis-ci.org/rust-datetime/zoneinfo-parse.svg)](https://travis-ci.org/rust-datetime/zoneinfo-parse) [![Coverage status](https://coveralls.io/repos/rust-datetime/zoneinfo-parse/badge.svg?branch=master&service=github)](https://coveralls.io/github/rust-datetime/zoneinfo-parse?branch=master)
 
-Rust library for reading [Time Zone database](https://github.com/eggert/tz) files.
+Rust library for reading the text files comprising the [zoneinfo database](^w), which records time zone changes and offsets across the world from multiple sources.
+
+The zoneinfo database is distributed in one of two formats: a raw text format with one file per continent, and a compiled binary format with one file per time zone. This crate deals with the former; for the latter, see the [`zoneinfo_compiled` crate](^zc) instead.
+
+The database itself is maintained by IANA. For more information, see [IANA’s page on the time zone database](^iana). You can also find the text files themselves in [the tz repository](^tz).
+
+[^iana]: https://www.iana.org/time-zones
+[^tz]: https://github.com/eggert/tz
+[^w]: https://en.wikipedia.org/wiki/Tz_database
+[^zc]: https://github.com/rust-datetime/zoneinfo-compiled
+
+### [View the Rustdoc](https://datetime.rustdocs.org/zoneinfo_parse/index.html)
+
+
+## Format
+
+The zoneinfo files contains `Zone`, `Rule`, and `Link` information. Each type of line forms a variant in the [`line::Line`](https://datetime.rustdocs.org/zoneinfo_parse/line/enum.Line.html) enum.
+
+To get started, here are a few lines representing what time is like in the `Europe/Madrid` time zone:
+
+    # Zone      NAME            GMTOFF  RULES   FORMAT  [UNTIL]
+    Zone        Europe/Madrid   -0:14:44 -      LMT     1901 Jan  1  0:00s
+                                 0:00   Spain   WE%sT   1946 Sep 30
+                                 1:00   Spain   CE%sT   1979
+                                 1:00   EU      CE%sT
+
+The first line is a comment. The second starts with `Zone`, so we know
+
+So parsing these five lines would return the five following results:
+
+- A `line::Line::Space` for the comment, because the line doesn’t contain any information (but isn’t strictly *invalid* either).
+- A `line::Line::Zone` for the first `Zone` entry. This contains a [`Zone` struct](https://datetime.rustdocs.org/zoneinfo_parse/line/struct.Zone.html) that holds the name of the zone. All the other fields are stored in the [`ZoneInfo` struct](https://datetime.rustdocs.org/zoneinfo_parse/line/struct.ZoneInfo.html).
+- A `line::Line::Continuation` for the next entry. This is different from the line above as it doesn’t contain a name field; it only has the information in a `ZoneInfo` struct.
+- The fourth line contains the same types of data as the third.
+- As does the fifth.
+
+Lines with rule definitions look like this:
+
+    # Rule      NAME    FROM    TO      TYPE    IN      ON      AT      SAVE    LETTER/S
+    Rule        Spain   1917    only    -       May      5      23:00s  1:00    S
+    Rule        Spain   1917    1919    -       Oct      6      23:00s  0       -
+    Rule        Spain   1918    only    -       Apr     15      23:00s  1:00    S
+    Rule        Spain   1919    only    -       Apr      5      23:00s  1:00    S
+
+All these lines follow the same pattern: A `line::Line::Rule` that contains a [`Rule` struct](https://datetime.rustdocs.org/zoneinfo_parse/line/struct.Rule.html), which has a field for each column of data.
+
+Finally, there are lines that link one zone to another’s name:
+
+    Link   Europe/Prague   Europe/Bratislava
+
+The [`Link` struct](https://datetime.rustdocs.org/zoneinfo_parse/line/struct.Link.html) simply contains the names of both the existing and new time zones.
+
+
+## Interpretation
+
+Once the input lines have been parsed, they must be *interpreted* to form a table of time zone data.
+
+The easiest way to do this is with a [`TableBuilder`](https://datetime.rustdocs.org/zoneinfo_parse/table/struct.TableBuilder.html). You can add various lines to the builder, and it will throw an error as soon as it detects that something’s wrong, such as a duplicate or a missing entry. When all the lines have been fed to the builder, you can use the `build` method to produce a [`Table`](https://datetime.rustdocs.org/zoneinfo_parse/table/struct.Table.html) containing fields for the rule, zone, and link lines.
+
+
+
+## Example program
+
+This crate is used to produce the data for the [`zoneinfo-data` crate](https://github.com/rust-datetime/zoneinfo-data). For an example of its use, see the bundled [data crate builder](https://github.com/rust-datetime/zoneinfo-data).
\ No newline at end of file

From 7d93800cb5b6304a3dd24284b90400b93132ca80 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 18:05:48 +0000
Subject: [PATCH 055/113] Fix Markdown link syntax, oops

---
 README.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index b80fb48..4d44304 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,15 @@
 # zoneinfo-parse [![Build status](https://travis-ci.org/rust-datetime/zoneinfo-parse.svg)](https://travis-ci.org/rust-datetime/zoneinfo-parse) [![Coverage status](https://coveralls.io/repos/rust-datetime/zoneinfo-parse/badge.svg?branch=master&service=github)](https://coveralls.io/github/rust-datetime/zoneinfo-parse?branch=master)
 
-Rust library for reading the text files comprising the [zoneinfo database](^w), which records time zone changes and offsets across the world from multiple sources.
+Rust library for reading the text files comprising the [zoneinfo database][w], which records time zone changes and offsets across the world from multiple sources.
 
-The zoneinfo database is distributed in one of two formats: a raw text format with one file per continent, and a compiled binary format with one file per time zone. This crate deals with the former; for the latter, see the [`zoneinfo_compiled` crate](^zc) instead.
+The zoneinfo database is distributed in one of two formats: a raw text format with one file per continent, and a compiled binary format with one file per time zone. This crate deals with the former; for the latter, see the [`zoneinfo_compiled` crate][zc] instead.
 
-The database itself is maintained by IANA. For more information, see [IANA’s page on the time zone database](^iana). You can also find the text files themselves in [the tz repository](^tz).
+The database itself is maintained by IANA. For more information, see [IANA’s page on the time zone database][iana]. You can also find the text files themselves in [the tz repository][tz].
 
-[^iana]: https://www.iana.org/time-zones
-[^tz]: https://github.com/eggert/tz
-[^w]: https://en.wikipedia.org/wiki/Tz_database
-[^zc]: https://github.com/rust-datetime/zoneinfo-compiled
+[iana]: https://www.iana.org/time-zones
+[tz]: https://github.com/eggert/tz
+[w]: https://en.wikipedia.org/wiki/Tz_database
+[zc]: https://github.com/rust-datetime/zoneinfo-compiled
 
 ### [View the Rustdoc](https://datetime.rustdocs.org/zoneinfo_parse/index.html)
 

From a46e8aee42335b9a24967a36457436be69932a92 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 18:30:57 +0000
Subject: [PATCH 056/113] Add the basic outline to the documentation

---
 src/lib.rs | 29 ++++++++++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/src/lib.rs b/src/lib.rs
index 965c714..b59415c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,31 @@
-//! Parsing Olson DB formats.
+//! Rust library for reading the text files comprising the [zoneinfo
+//! database][w], which records time zone changes and offsets across the world
+//! from multiple sources.
+//!
+//! The zoneinfo database is distributed in one of two formats: a raw text
+//! format with one file per continent, and a compiled binary format with one
+//! file per time zone. This crate deals with the former; for the latter, see
+//! the [`zoneinfo_compiled` crate][zc] instead.
+//!
+//! The database itself is maintained by IANA. For more information, see
+//! [IANA’s page on the time zone database][iana]. You can also find the text
+//! files themselves in [the tz repository][tz].
+//!
+//! [iana]: https://www.iana.org/time-zones
+//! [tz]: https://github.com/eggert/tz
+//! [w]: https://en.wikipedia.org/wiki/Tz_database
+//! [zc]: https://datetime.rustdocs.org/zoneinfo_compiled/index.html
+//!
+//! ## Outline
+//!
+//! Reading a zoneinfo text file is split into three stages:
+//!
+//! - **Parsing** individual lines of text into `Lines` is done by the `line`
+//!   module;
+//! - **Interpreting** these lines into a complete `Table` is done by the
+//!   `table` module;
+//! - **Calculating transitions** from this table is done by the `transitions`
+//!   module.
 
 #![crate_name = "zoneinfo_parse"]
 #![crate_type = "rlib"]

From d31c5cfffd4c9c2f1927b156d222a733e99401fa Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 18:53:28 +0000
Subject: [PATCH 057/113] Copy some of the tests to doctests

---
 src/line.rs | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 72 insertions(+), 3 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index 653ecc4..6e87301 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -5,8 +5,77 @@
 //! it gets parsed successfully. It classifies them as `Rule`, `Link`,
 //! `Zone`, or `Continuation` lines.
 //!
-//! The actual *interpretation* of what the details mean is done by the
-//! `table` module.
+//! `Line` is the type that parses and holds zoneinfo line data. To try to
+//! parse a string, use the `Line::from_str` constructor. (This isn’t the
+//! `FromStr` trait, so you can’t use `parse` on a string. Sorry!)
+//!
+//! ## Examples
+//!
+//! Parsing a `Rule` line:
+//!
+//! ```
+//! # extern crate datetime;
+//! # extern crate zoneinfo_parse;
+//! # fn main() {
+//! use zoneinfo_parse::line::*;
+//! use datetime::{Month, Weekday};
+//! use datetime::zone::TimeType;
+//!
+//! let line = Line::from_str("Rule  EU  1977    1980    -   Apr Sun>=1   1:00u  1:00    S");
+//!
+//! assert_eq!(line, Ok(Line::Rule(Rule {
+//!     name:         "EU",
+//!     from_year:    YearSpec::Number(1977),
+//!     to_year:      Some(YearSpec::Number(1980)),
+//!     month:        MonthSpec(Month::April),
+//!     day:          DaySpec::FirstOnOrAfter(WeekdaySpec(Weekday::Sunday), 1),
+//!     time:         TimeSpec::HoursMinutes(1, 0).with_type(TimeType::UTC),
+//!     time_to_add:  TimeSpec::HoursMinutes(1, 0),
+//!     letters:      Some("S"),
+//! })));
+//! # }
+//! ```
+//!
+//! Parsing a `Zone` line:
+//!
+//! ```
+//! # extern crate datetime;
+//! # extern crate zoneinfo_parse;
+//! # fn main() {
+//! use zoneinfo_parse::line::*;
+//! use datetime::{Month, Weekday};
+//! use datetime::zone::TimeType;
+//!
+//! let line = Line::from_str("Zone  Australia/Adelaide  9:30  Aus  AC%sT  1971 Oct 31  2:00:00");
+//!
+//! assert_eq!(line, Ok(Line::Zone(Zone {
+//!     name: "Australia/Adelaide",
+//!     info: ZoneInfo {
+//!         utc_offset:  TimeSpec::HoursMinutes(9, 30),
+//!         saving:      Saving::Multiple("Aus"),
+//!         format:      "AC%sT",
+//!         time:        Some(ChangeTime::UntilTime(
+//!                         YearSpec::Number(1971),
+//!                         MonthSpec(Month::October),
+//!                         DaySpec::Ordinal(31),
+//!                         TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))
+//!                      ),
+//!     },
+//! })));
+//! # }
+//! ```
+//!
+//! Parsing a `Link` line:
+//!
+//! ```
+//! use zoneinfo_parse::line::*;
+//!
+//! let line = Line::from_str("Link  Europe/Istanbul  Asia/Istanbul");
+//! assert_eq!(line, Ok(Line::Link(Link {
+//!     existing:  "Europe/Istanbul",
+//!     new:       "Asia/Istanbul",
+//! })));
+//! ```
 
 use std::ascii::AsciiExt;
 use std::error::Error as ErrorTrait;
@@ -801,7 +870,7 @@ mod test {
         })));
 
         test!(rule_3: "Rule	EU	1977	1980	-	Apr	Sun>=1	 1:00u	1:00	S" => Ok(Line::Rule(Rule {
-            name:        "EU",
+            name:         "EU",
             from_year:    YearSpec::Number(1977),
             to_year:      Some(YearSpec::Number(1980)),
             month:        MonthSpec(Month::April),

From 5a912a301adc899fad0ee442882123e89d9c9364 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 19:28:53 +0000
Subject: [PATCH 058/113] Change panic call to returning an Option

Trying to get a non-existent timezone out of a table used to panic... which worked well until I needed to write a test showing that it would fail! So this commit changes it to returning None instead.
---
 data-crate-builder/src/data_crate.rs |  2 +-
 src/table.rs                         |  8 ++++----
 src/transitions.rs                   | 15 ++++++++++-----
 tests/transition_tests.rs            | 20 ++++++++++----------
 4 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/data-crate-builder/src/data_crate.rs b/data-crate-builder/src/data_crate.rs
index 82bebb7..35dfa17 100644
--- a/data-crate-builder/src/data_crate.rs
+++ b/data-crate-builder/src/data_crate.rs
@@ -189,7 +189,7 @@ impl DataCrate {
             try!(writeln!(w, "    name: {:?},", name));
             try!(writeln!(w, "    fixed_timespans: FixedTimespanSet {{"));
 
-            let set = self.table.timespans(&*name);
+            let set = self.table.timespans(&*name).unwrap();
 
             try!(writeln!(w, "        first: FixedTimespan {{"));
             try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", set.first.total_offset(), set.first.utc_offset, set.first.dst_offset));
diff --git a/src/table.rs b/src/table.rs
index da7b807..55a32e9 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -41,16 +41,16 @@ impl Table {
 
     /// Tries to find the zoneset with the given name by looking it up in
     /// either the zonesets map or the links map.
-    pub fn get_zoneset(&self, zone_name: &str) -> &[ZoneInfo] {
+    pub fn get_zoneset(&self, zone_name: &str) -> Option<&[ZoneInfo]> {
         if self.zonesets.contains_key(zone_name) {
-            &*self.zonesets[zone_name]
+            Some(&*self.zonesets[zone_name])
         }
         else if self.links.contains_key(zone_name) {
             let target = &self.links[zone_name];
-            &*self.zonesets[&*target]
+            Some(&*self.zonesets[&*target])
         }
         else {
-            panic!("No such zone: {:?}", zone_name);
+            None
         }
     }
 }
diff --git a/src/transitions.rs b/src/transitions.rs
index 19b7014..d6407cd 100644
--- a/src/transitions.rs
+++ b/src/transitions.rs
@@ -157,17 +157,22 @@ impl FixedTimespan {
 /// Trait to put the `timespans` method on Tables.
 pub trait TableTransitions {
 
-    fn timespans(&self, zone_name: &str) -> FixedTimespanSet;
+    /// Computes a fixed timespan set for the timezone with the given name.
+    /// Returns `None` if the table doesn’t contain a time zone with that name.
+    fn timespans(&self, zone_name: &str) -> Option<FixedTimespanSet>;
 }
 
 
 impl TableTransitions for Table {
 
-    /// Computes a fixed timespan set for the timezone with the given name.
-    fn timespans(&self, zone_name: &str) -> FixedTimespanSet {
+    fn timespans(&self, zone_name: &str) -> Option<FixedTimespanSet> {
         let mut builder = FixedTimespanSetBuilder::default();
 
-        let zoneset = self.get_zoneset(zone_name);
+        let zoneset = match self.get_zoneset(zone_name) {
+            Some(zones) => zones,
+            None => return None,
+        };
+
         for (i, zone_info) in zoneset.iter().enumerate() {
             let mut dst_offset = 0;
             let use_until      = i != zoneset.len() - 1;
@@ -207,7 +212,7 @@ impl TableTransitions for Table {
             }
         }
 
-        builder.build()
+        Some(builder.build())
     }
 }
 
diff --git a/tests/transition_tests.rs b/tests/transition_tests.rs
index 2b092c2..d837b0d 100644
--- a/tests/transition_tests.rs
+++ b/tests/transition_tests.rs
@@ -20,10 +20,10 @@ fn no_transitions() {
     let mut table = Table::default();
     table.zonesets.insert("Test/Zone".to_owned(), vec![ zone ]);
 
-    assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+    assert_eq!(table.timespans("Test/Zone"), Some(FixedTimespanSet {
         first: FixedTimespan { utc_offset: 1234, dst_offset: 0, name: "TEST".to_owned() },
         rest:  vec![],
-    });
+    }));
 }
 
 #[test]
@@ -52,7 +52,7 @@ fn one_transition() {
         ],
     };
 
-    assert_eq!(table.timespans("Test/Zone"), expected);
+    assert_eq!(table.timespans("Test/Zone"), Some(expected));
 }
 
 
@@ -98,7 +98,7 @@ fn two_transitions() {
         ],
     };
 
-    assert_eq!(table.timespans("Test/Zone"), expected);
+    assert_eq!(table.timespans("Test/Zone"), Some(expected));
 }
 
 #[test]
@@ -134,12 +134,12 @@ fn one_rule() {
     table.zonesets.insert("Test/Zone".to_owned(), vec![ lmt, zone ]);
     table.rulesets.insert("Dwayne".to_owned(), ruleset);
 
-    assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+    assert_eq!(table.timespans("Test/Zone"), Some(FixedTimespanSet {
         first: FixedTimespan { utc_offset: 0, dst_offset: 0, name: "LMT".to_owned() },
         rest:  vec![
             (318_470_400, FixedTimespan { utc_offset: 2000, dst_offset: 1000, name: "TEST".to_owned() })
         ],
-    });
+    }));
 }
 
 #[test]
@@ -185,13 +185,13 @@ fn two_rules() {
     table.zonesets.insert("Test/Zone".to_owned(), vec![ lmt, zone ]);
     table.rulesets.insert("Dwayne".to_owned(), ruleset);
 
-    assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+    assert_eq!(table.timespans("Test/Zone"), Some(FixedTimespanSet {
         first: FixedTimespan { utc_offset: 0, dst_offset: 0, name: "LMT".to_owned() },
         rest: vec![
             (318_470_400, FixedTimespan { utc_offset: 2000, dst_offset: 1000, name: "TEST".to_owned() }),
             (600_566_400, FixedTimespan { utc_offset: 2000, dst_offset: 1500, name: "TEST".to_owned() }),
         ],
-    });
+    }));
 }
 
 #[test]
@@ -232,7 +232,7 @@ fn tripoli() {
     table.zonesets.insert("Test/Zone".to_owned(), zone);
     table.rulesets.insert("Libya".to_owned(), libya);
 
-    assert_eq!(table.timespans("Test/Zone"), FixedTimespanSet {
+    assert_eq!(table.timespans("Test/Zone"), Some(FixedTimespanSet {
         first: FixedTimespan { utc_offset: 3164,  dst_offset:    0,  name:  "LMT".to_owned() },
         rest: vec![
             (-1_577_926_364, FixedTimespan { utc_offset: 3600,  dst_offset:    0,  name:  "CET".to_owned() }),
@@ -268,5 +268,5 @@ fn tripoli() {
             ( 1_364_515_200, FixedTimespan { utc_offset: 3600,  dst_offset: 3600,  name: "CEST".to_owned() }),
             ( 1_382_659_200, FixedTimespan { utc_offset: 7200,  dst_offset:    0,  name:  "EET".to_owned() }),
         ],
-    });
+    }));
 }

From d5518e35143316fe09b15946595318f702f72e2a Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 19:29:23 +0000
Subject: [PATCH 059/113] Add doctest to demonstrate Table functionality

---
 src/line.rs  | 10 +++++++---
 src/table.rs | 26 +++++++++++++++++++++++---
 2 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index 6e87301..6bbedc5 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -208,7 +208,7 @@ pub struct Rule<'line> {
 impl<'line> Rule<'line> {
 
     /// Attempts to parse the given string into a value of this type.
-    fn from_str(input: &str) -> Result<Rule, Error> {
+    pub fn from_str(input: &str) -> Result<Rule, Error> {
         if let Some(caps) = RULE_LINE.captures(input) {
             let name      = caps.name("name").unwrap();
             let from_year = try!(caps.name("from").unwrap().parse());
@@ -286,7 +286,9 @@ pub struct Zone<'line> {
 }
 
 impl<'line> Zone<'line> {
-    fn from_str(input: &str) -> Result<Zone, Error> {
+
+    /// Attempts to parse the given string into a value of this type.
+    pub fn from_str(input: &str) -> Result<Zone, Error> {
         if let Some(caps) = ZONE_LINE.captures(input) {
             let name = caps.name("name").unwrap();
             let info = try!(ZoneInfo::from_captures(caps));
@@ -453,7 +455,9 @@ pub struct Link<'line> {
 }
 
 impl<'line> Link<'line> {
-    fn from_str(input: &str) -> Result<Link, Error> {
+
+    /// Attempts to parse the given string into a value of this type.
+    pub fn from_str(input: &str) -> Result<Link, Error> {
         if let Some(caps) = LINK_LINE.captures(input) {
             let target  = caps.name("target").unwrap();
             let name    = caps.name("name").unwrap();
diff --git a/src/table.rs b/src/table.rs
index 55a32e9..034c569 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -5,13 +5,33 @@
 //! set of data.
 //!
 //! It’s not as simple as it seems, because the zoneinfo data lines refer to
-//! each other through strings: lines of the form "link zone A to B" could be
+//! each other through strings: lines of the form “link zone A to B” could be
 //! *parsed* successfully but still fail to be *interpreted* successfully if
-//! "B" doesn't exist. So it has to check every step of the way—nothing wrong
-//! with this, it's just a consequence of reading data from a text file.
+//! “B” doesn’t exist. So it has to check every step of the way—nothing wrong
+//! with this, it’s just a consequence of reading data from a text file.
 //!
 //! This module only deals with constructing a table from data: any analysis
 //! of the data is done elsewhere.
+//!
+//!
+//! ## Example
+//!
+//! ```
+//! use zoneinfo_parse::line::{Zone, Link};
+//! use zoneinfo_parse::table::{TableBuilder};
+//!
+//! let zone = Zone::from_str("Zone  Pacific/Auckland  11:39:04  -  LMT  1868  Nov  2").unwrap();
+//! let link = Link::from_str("Link  Pacific/Auckland  Antarctica/McMurdo").unwrap();
+//!
+//! let mut builder = TableBuilder::new();
+//! builder.add_zone_line(zone).unwrap();
+//! builder.add_link_line(link).unwrap();
+//! let table = builder.build();
+//!
+//! assert!(table.get_zoneset("Pacific/Auckland").is_some());
+//! assert!(table.get_zoneset("Antarctica/McMurdo").is_some());
+//! assert!(table.get_zoneset("UTC").is_none());
+//! ```
 
 use std::collections::hash_map::{HashMap, Entry};
 use std::error::Error as ErrorTrait;

From da27df4daac6880449bca444f14fdbf48ed51509 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Fri, 12 Feb 2016 23:20:09 +0000
Subject: [PATCH 060/113] Rewrite builder to use perfect hash functions

---
 data-crate-builder/Cargo.toml        |  1 +
 data-crate-builder/src/data_crate.rs | 16 +++++++++++-----
 data-crate-builder/src/main.rs       |  3 ++-
 3 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/data-crate-builder/Cargo.toml b/data-crate-builder/Cargo.toml
index 7d717c5..3f74ac3 100644
--- a/data-crate-builder/Cargo.toml
+++ b/data-crate-builder/Cargo.toml
@@ -9,6 +9,7 @@ path = "src/main.rs"
 
 [dependencies]
 getopts = "0.2"
+phf_codegen = "0.7.12"
 quick-error = "0.2"
 
 [dependencies.zoneinfo_parse]
diff --git a/data-crate-builder/src/data_crate.rs b/data-crate-builder/src/data_crate.rs
index 35dfa17..a3ff92f 100644
--- a/data-crate-builder/src/data_crate.rs
+++ b/data-crate-builder/src/data_crate.rs
@@ -15,6 +15,8 @@ use zoneinfo_parse::table::{Table, TableBuilder};
 use zoneinfo_parse::structure::{Structure, Child};
 use zoneinfo_parse::transitions::{TableTransitions};
 
+use phf_codegen::Map as PHFMap;
+
 use errors::{Error, ParseError};
 
 
@@ -164,13 +166,16 @@ impl DataCrate {
         }
 
         try!(writeln!(base_w, "\n\n"));
-        try!(writeln!(base_w, "pub fn lookup(input: &str) -> Option<&'static StaticTimeZone<'static>> {{"));
+        try!(write!(base_w, "static ZONES: phf::Map<&'static str, &'static StaticTimeZone<'static>> = "));
+
+        let mut phf_map = PHFMap::new();
         for name in &keys {
-            try!(writeln!(base_w, "    if input == {:?} {{", name));
-            try!(writeln!(base_w, "        return Some(&{});", sanitise_name(name).replace("/", "::")));
-            try!(writeln!(base_w, "    }}"));
+            phf_map.entry(&***name, &format!("&{}", sanitise_name(name).replace("/", "::")));
         }
-        try!(writeln!(base_w, "    return None;"));
+        try!(phf_map.build(&mut base_w));
+
+        try!(writeln!(base_w, ";\n\npub fn lookup(input: &str) -> Option<&'static StaticTimeZone<'static>> {{"));
+        try!(writeln!(base_w, "    ZONES.get(input).cloned()"));
         try!(writeln!(base_w, "}}"));
 
         Ok(())
@@ -244,4 +249,5 @@ use datetime::zone::{StaticTimeZone, FixedTimespanSet, FixedTimespan};
 /// The imports needed for a `mod.rs` file.
 const MOD_HEADER: &'static str = r##"
 use datetime::zone::StaticTimeZone;
+use phf;
 "##;
diff --git a/data-crate-builder/src/main.rs b/data-crate-builder/src/main.rs
index 3ebf11e..a5b9660 100644
--- a/data-crate-builder/src/main.rs
+++ b/data-crate-builder/src/main.rs
@@ -2,8 +2,9 @@ use std::env::args_os;
 use std::io::{Write, stderr};
 use std::process::exit;
 
-extern crate getopts;
 extern crate datetime;
+extern crate getopts;
+extern crate phf_codegen;
 extern crate zoneinfo_parse;
 
 #[macro_use]

From 2cebd356de0ee975f27a0adcadd0aedd354b19f1 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sun, 25 Sep 2016 16:26:51 +0100
Subject: [PATCH 061/113] Version and docs link bump

---
 Cargo.toml |  7 ++++---
 README.md  | 14 +++++++-------
 src/lib.rs |  2 +-
 3 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 4283c6b..ed9055c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,11 +1,12 @@
 [package]
 name = "zoneinfo_parse"
-version = "0.1.0"
+version = "0.1.2"
 authors = ["Ben S <ogham@bsago.me>"]
+documentation = "https://docs.rs/zoneinfo_parse"
 
 [dependencies]
-lazy_static = "*"
-regex = "*"
+lazy_static = "0.2.1"
+regex = "0.1.77"
 
 [dependencies.datetime]
 git = "https://github.com/rust-datetime/datetime.git"
diff --git a/README.md b/README.md
index 4d44304..ddbf1c3 100644
--- a/README.md
+++ b/README.md
@@ -11,12 +11,12 @@ The database itself is maintained by IANA. For more information, see [IANA’s p
 [w]: https://en.wikipedia.org/wiki/Tz_database
 [zc]: https://github.com/rust-datetime/zoneinfo-compiled
 
-### [View the Rustdoc](https://datetime.rustdocs.org/zoneinfo_parse/index.html)
+### [View the Rustdoc](https://docs.rs/zoneinfo_parse)
 
 
 ## Format
 
-The zoneinfo files contains `Zone`, `Rule`, and `Link` information. Each type of line forms a variant in the [`line::Line`](https://datetime.rustdocs.org/zoneinfo_parse/line/enum.Line.html) enum.
+The zoneinfo files contains `Zone`, `Rule`, and `Link` information. Each type of line forms a variant in the `line::Line` enum.
 
 To get started, here are a few lines representing what time is like in the `Europe/Madrid` time zone:
 
@@ -31,7 +31,7 @@ The first line is a comment. The second starts with `Zone`, so we know
 So parsing these five lines would return the five following results:
 
 - A `line::Line::Space` for the comment, because the line doesn’t contain any information (but isn’t strictly *invalid* either).
-- A `line::Line::Zone` for the first `Zone` entry. This contains a [`Zone` struct](https://datetime.rustdocs.org/zoneinfo_parse/line/struct.Zone.html) that holds the name of the zone. All the other fields are stored in the [`ZoneInfo` struct](https://datetime.rustdocs.org/zoneinfo_parse/line/struct.ZoneInfo.html).
+- A `line::Line::Zone` for the first `Zone` entry. This contains a `Zone` struct that holds the name of the zone. All the other fields are stored in the `ZoneInfo` struct.
 - A `line::Line::Continuation` for the next entry. This is different from the line above as it doesn’t contain a name field; it only has the information in a `ZoneInfo` struct.
 - The fourth line contains the same types of data as the third.
 - As does the fifth.
@@ -44,23 +44,23 @@ Lines with rule definitions look like this:
     Rule        Spain   1918    only    -       Apr     15      23:00s  1:00    S
     Rule        Spain   1919    only    -       Apr      5      23:00s  1:00    S
 
-All these lines follow the same pattern: A `line::Line::Rule` that contains a [`Rule` struct](https://datetime.rustdocs.org/zoneinfo_parse/line/struct.Rule.html), which has a field for each column of data.
+All these lines follow the same pattern: A `line::Line::Rule` that contains a `Rule` struct, which has a field for each column of data.
 
 Finally, there are lines that link one zone to another’s name:
 
     Link   Europe/Prague   Europe/Bratislava
 
-The [`Link` struct](https://datetime.rustdocs.org/zoneinfo_parse/line/struct.Link.html) simply contains the names of both the existing and new time zones.
+The `Link` struct simply contains the names of both the existing and new time zones.
 
 
 ## Interpretation
 
 Once the input lines have been parsed, they must be *interpreted* to form a table of time zone data.
 
-The easiest way to do this is with a [`TableBuilder`](https://datetime.rustdocs.org/zoneinfo_parse/table/struct.TableBuilder.html). You can add various lines to the builder, and it will throw an error as soon as it detects that something’s wrong, such as a duplicate or a missing entry. When all the lines have been fed to the builder, you can use the `build` method to produce a [`Table`](https://datetime.rustdocs.org/zoneinfo_parse/table/struct.Table.html) containing fields for the rule, zone, and link lines.
+The easiest way to do this is with a `TableBuilder`. You can add various lines to the builder, and it will throw an error as soon as it detects that something’s wrong, such as a duplicate or a missing entry. When all the lines have been fed to the builder, you can use the `build` method to produce a `Table` containing fields for the rule, zone, and link lines.
 
 
 
 ## Example program
 
-This crate is used to produce the data for the [`zoneinfo-data` crate](https://github.com/rust-datetime/zoneinfo-data). For an example of its use, see the bundled [data crate builder](https://github.com/rust-datetime/zoneinfo-data).
\ No newline at end of file
+This crate is used to produce the data for the [`zoneinfo-data` crate](https://github.com/rust-datetime/zoneinfo-data). For an example of its use, see the bundled [data crate builder](https://github.com/rust-datetime/zoneinfo-parse/tree/master/data-crate-builder).
diff --git a/src/lib.rs b/src/lib.rs
index b59415c..3384c50 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -14,7 +14,7 @@
 //! [iana]: https://www.iana.org/time-zones
 //! [tz]: https://github.com/eggert/tz
 //! [w]: https://en.wikipedia.org/wiki/Tz_database
-//! [zc]: https://datetime.rustdocs.org/zoneinfo_compiled/index.html
+//! [zc]: https://github.com/rust-datetime/zoneinfo-compiled
 //!
 //! ## Outline
 //!

From a73e1a19b4772f1c5992214999e4c77d3692c173 Mon Sep 17 00:00:00 2001
From: Ben S <ogham@bsago.me>
Date: Sun, 25 Sep 2016 16:32:19 +0100
Subject: [PATCH 062/113] Use the published datetime version, not one from Git

---
 Cargo.toml | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index ed9055c..7cae7d0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,12 +1,15 @@
 [package]
 name = "zoneinfo_parse"
+description = "Library for parsing zoneinfo time zone files"
+
 version = "0.1.2"
-authors = ["Ben S <ogham@bsago.me>"]
 documentation = "https://docs.rs/zoneinfo_parse"
+homepage = "https://github.com/rust-datetime/zoneinfo-compiled"
+license = "MIT"
+readme = "README.md"
+authors = ["Ben S <ogham@bsago.me>"]
 
 [dependencies]
+datetime = "0.4.4"
 lazy_static = "0.2.1"
 regex = "0.1.77"
-
-[dependencies.datetime]
-git = "https://github.com/rust-datetime/datetime.git"

From 965cd2a7273d416d4529dd36862c954434e6cbbd Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Thu, 6 Oct 2016 00:39:38 +0300
Subject: [PATCH 063/113] Fix invalid lifetime name

---
 src/table.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/table.rs b/src/table.rs
index 034c569..866b69a 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -111,7 +111,7 @@ pub struct RuleInfo {
     pub letters: Option<String>,
 }
 
-impl<'_> From<line::Rule<'_>> for RuleInfo {
+impl<'line> From<line::Rule<'line>> for RuleInfo {
     fn from(info: line::Rule) -> RuleInfo {
         RuleInfo {
             from_year:    info.from_year,
@@ -183,7 +183,7 @@ pub struct ZoneInfo {
     pub end_time: Option<ChangeTime>,
 }
 
-impl<'_> From<line::ZoneInfo<'_>> for ZoneInfo {
+impl<'line> From<line::ZoneInfo<'line>> for ZoneInfo {
     fn from(info: line::ZoneInfo) -> ZoneInfo {
         ZoneInfo {
             offset: info.utc_offset.as_seconds(),

From 4aa23d014b8dc36cd5b92e1540dec713851332ab Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Thu, 6 Oct 2016 14:38:29 +0100
Subject: [PATCH 064/113] Version bump and lint fix

---
 Cargo.toml         | 2 +-
 src/transitions.rs | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 7cae7d0..31ff61c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,7 @@
 name = "zoneinfo_parse"
 description = "Library for parsing zoneinfo time zone files"
 
-version = "0.1.2"
+version = "0.1.3"
 documentation = "https://docs.rs/zoneinfo_parse"
 homepage = "https://github.com/rust-datetime/zoneinfo-compiled"
 license = "MIT"
diff --git a/src/transitions.rs b/src/transitions.rs
index d6407cd..3932b87 100644
--- a/src/transitions.rs
+++ b/src/transitions.rs
@@ -253,6 +253,7 @@ impl FixedTimespanSetBuilder {
         }
     }
 
+    #[allow(unused_results)]
     fn add_multiple_saving(&mut self, timespan: &ZoneInfo, rules: &[RuleInfo],
             dst_offset: &mut i64, use_until: bool, utc_offset: i64, insert_start_transition: &mut bool,
             start_zone_id: &mut Option<String>, start_utc_offset: &mut i64, start_dst_offset: &mut i64)

From 6040286bf681a7a666708b09a976b39c5cc67a4a Mon Sep 17 00:00:00 2001
From: Djzin <djzin@users.noreply.github.com>
Date: Sun, 9 Oct 2016 12:22:48 +0100
Subject: [PATCH 065/113] add tests for negative offsets & provide a fix

---
 src/line.rs | 47 ++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 36 insertions(+), 11 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index 6bbedc5..d59fc85 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -117,13 +117,15 @@ lazy_static! {
 
     /// Format of an hour and a minute specification.
     static ref HM_FIELD: Regex = Regex::new(r##"(?x) ^
-        ( ?P<hour> -? \d{1,2} ) : ( ?P<minute> \d{2} )
+        ( ?P<sign> -? )
+        ( ?P<hour> \d{1,2} ) : ( ?P<minute> \d{2} )
         ( ?P<flag> [wsugz] )?
     $ "##).unwrap();
 
     /// Format of an hour, a minute, and a second specification.
     static ref HMS_FIELD: Regex = Regex::new(r##"(?x) ^
-        ( ?P<hour> -? \d{1,2} ) : ( ?P<minute> \d{2} ) : ( ?P<second> \d{2} )
+        ( ?P<sign> -? )
+        ( ?P<hour> \d{1,2} ) : ( ?P<minute> \d{2} ) : ( ?P<second> \d{2} )
         ( ?P<flag> [wsugz] )?
     $ "##).unwrap();
 
@@ -713,21 +715,23 @@ impl FromStr for TimeSpecAndType {
             Ok(TimeSpecAndType(TimeSpec::Hours(input.parse().unwrap()), TimeType::Wall))
         }
         else if let Some(caps) = HM_FIELD.captures(input) {
-            let hour   = caps.name("hour").unwrap().parse().unwrap();
-            let minute = caps.name("minute").unwrap().parse().unwrap();
-            let flag   = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
+            let sign   : i8 = if caps.name("sign").unwrap() == "-" { -1 } else { 1 };
+            let hour   : i8 = caps.name("hour").unwrap().parse().unwrap();
+            let minute : i8 = caps.name("minute").unwrap().parse().unwrap();
+            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
                                           .unwrap_or(TimeType::Wall);
 
-            Ok(TimeSpecAndType(TimeSpec::HoursMinutes(hour, minute), flag))
+            Ok(TimeSpecAndType(TimeSpec::HoursMinutes(hour * sign, minute * sign), flag))
         }
         else if let Some(caps) = HMS_FIELD.captures(input) {
-            let hour   = caps.name("hour").unwrap().parse().unwrap();
-            let minute = caps.name("minute").unwrap().parse().unwrap();
-            let second = caps.name("second").unwrap().parse().unwrap();
-            let flag   = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
+            let sign   : i8 = if caps.name("sign").unwrap() == "-" { -1 } else { 1 };
+            let hour   : i8 = caps.name("hour").unwrap().parse().unwrap();
+            let minute : i8 = caps.name("minute").unwrap().parse().unwrap();
+            let second : i8 = caps.name("second").unwrap().parse().unwrap();
+            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
                                           .unwrap_or(TimeType::Wall);
 
-            Ok(TimeSpecAndType(TimeSpec::HoursMinutesSeconds(hour, minute, second), flag))
+            Ok(TimeSpecAndType(TimeSpec::HoursMinutesSeconds(hour * sign, minute * sign, second * sign), flag))
         }
         else {
             Err(Error::Fail)
@@ -925,6 +929,27 @@ mod test {
                 time:        Some(ChangeTime::UntilYear(YearSpec::Number(1919))),
             },
         })));
+
+        #[test]
+        fn negative_offsets() {
+            static LINE: &'static str = "Zone    Europe/London   -0:01:15 -  LMT 1847 Dec  1  0:00s";
+            let zone = Zone::from_str(LINE).unwrap();
+            assert_eq!(zone.info.utc_offset, TimeSpec::HoursMinutesSeconds(0, -1, -15));
+        }
+
+        #[test]
+        fn negative_offsets_2() {
+            static LINE: &'static str = "Zone        Europe/Madrid   -0:14:44 -      LMT     1901 Jan  1  0:00s";
+            let zone = Zone::from_str(LINE).unwrap();
+            assert_eq!(zone.info.utc_offset, TimeSpec::HoursMinutesSeconds(0, -14, -44));
+        }
+
+        #[test]
+        fn negative_offsets_3() {
+            static LINE: &'static str = "Zone America/Danmarkshavn -1:14:40 -    LMT 1916 Jul 28";
+            let zone = Zone::from_str(LINE).unwrap();
+            assert_eq!(zone.info.utc_offset, TimeSpec::HoursMinutesSeconds(-1, -14, -40));
+        }
     }
 
     test!(link: "Link  Europe/Istanbul  Asia/Istanbul" => Ok(Line::Link(Link {

From 0a0b732bd0621dec42cfbabfd907b88237913a86 Mon Sep 17 00:00:00 2001
From: Djzin <djzin@users.noreply.github.com>
Date: Sun, 9 Oct 2016 12:39:01 +0100
Subject: [PATCH 066/113] add test & fix for dushanbe parsing error

---
 src/transitions.rs        |  2 +-
 tests/transition_tests.rs | 26 ++++++++++++++++++++++++--
 2 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/transitions.rs b/src/transitions.rs
index 3932b87..1969335 100644
--- a/src/transitions.rs
+++ b/src/transitions.rs
@@ -231,7 +231,7 @@ impl FixedTimespanSetBuilder {
             start_zone_id: &mut Option<String>)
     {
         *dst_offset = amount;
-        *start_zone_id = Some(timespan.format.format_constant());
+        *start_zone_id = Some(timespan.format.format(*dst_offset, None));
 
         if *insert_start_transition {
             let time = self.start_time.unwrap();
diff --git a/tests/transition_tests.rs b/tests/transition_tests.rs
index d837b0d..599cf02 100644
--- a/tests/transition_tests.rs
+++ b/tests/transition_tests.rs
@@ -1,8 +1,8 @@
 extern crate zoneinfo_parse;
 extern crate datetime;
 
-use zoneinfo_parse::line::{DaySpec, WeekdaySpec, MonthSpec, YearSpec, TimeSpec, ChangeTime};
-use zoneinfo_parse::table::{Saving, ZoneInfo, RuleInfo, Table, Format};
+use zoneinfo_parse::line::{Line, DaySpec, WeekdaySpec, MonthSpec, YearSpec, TimeSpec, ChangeTime};
+use zoneinfo_parse::table::{Saving, ZoneInfo, RuleInfo, Table, Format, TableBuilder};
 use zoneinfo_parse::transitions::{FixedTimespan, FixedTimespanSet, TableTransitions};
 use datetime::Weekday::*;
 use datetime::Month::*;
@@ -270,3 +270,25 @@ fn tripoli() {
         ],
     }));
 }
+
+#[test]
+fn dushanbe() {
+    static ZONEINFO : &'static str = r#"
+Zone    Asia/Dushanbe   4:35:12 -   LMT 1924 May  2
+            5:00    1:00    +05/+06 1991 Sep  9  2:00s
+"#;
+
+    let mut table = TableBuilder::new();
+    for line in ZONEINFO.lines() {
+        let line = Line::from_str(line).unwrap();
+        match line {
+            Line::Zone(zone) => table.add_zone_line(zone).unwrap(),
+            Line::Continuation(cont) => table.add_continuation_line(cont).unwrap(),
+            Line::Rule(rule) => table.add_rule_line(rule).unwrap(),
+            Line::Link(link) => table.add_link_line(link).unwrap(),
+            Line::Space => {},
+        }
+    }
+    let table = table.build();
+    let _ = table.timespans("Asia/Dushanbe").unwrap();
+}

From 6b1161c32a1016ed53b82fa5023d24d5019fd28f Mon Sep 17 00:00:00 2001
From: Djzin <djzin@users.noreply.github.com>
Date: Sun, 9 Oct 2016 12:57:01 +0100
Subject: [PATCH 067/113] handle comment lines as Line::Space and add tests for
 comments

---
 src/line.rs | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/line.rs b/src/line.rs
index d59fc85..4a89c15 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -163,6 +163,11 @@ lazy_static! {
         ( ?P<target>  \S+ )  \s+
         ( ?P<name>    \S+ )
     "##).unwrap();
+
+    /// Format of an empty line, which contains only comments.
+    static ref EMPTY_LINE: Regex = Regex::new(r##"(?x) ^
+        \s* (\#.*)?
+    $"##).unwrap();
 }
 
 
@@ -811,7 +816,7 @@ impl<'line> Line<'line> {
     /// Attempt to parse this line, returning a `Line` depending on what
     /// type of line it was, or an `Error` if it couldn't be parsed.
     pub fn from_str(input: &str) -> Result<Line, Error> {
-        if input.is_empty() || input.chars().all(char::is_whitespace) {
+        if EMPTY_LINE.is_match(input) {
             Ok(Line::Space)
         }
         else if let Ok(zone) = Zone::from_str(input) {
@@ -964,4 +969,19 @@ mod test {
     }
 
     test!(golb: "GOLB" => Err(Error::Fail));
+
+    test!(comment: "# this is a comment" => Ok(Line::Space));
+    test!(another_comment: "     # so is this" => Ok(Line::Space));
+    test!(multiple_hash: "     # so is this ## " => Ok(Line::Space));
+    test!(non_comment: " this is not a # comment" => Err(Error::Fail));
+
+    test!(comment_after: "Link  Europe/Istanbul  Asia/Istanbul #with a comment after" => Ok(Line::Link(Link {
+        existing:  "Europe/Istanbul",
+        new:       "Asia/Istanbul",
+    })));
+
+    test!(two_comments_after: "Link  Europe/Istanbul  Asia/Istanbul   # comment ## comment" => Ok(Line::Link(Link {
+        existing:  "Europe/Istanbul",
+        new:       "Asia/Istanbul",
+    })));
 }

From d533d0a64c51507aa5f7c3b0b4d19ae5b0568ca3 Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Sun, 23 Oct 2016 12:15:12 +0100
Subject: [PATCH 068/113] Version bump

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 31ff61c..6181182 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,7 @@
 name = "zoneinfo_parse"
 description = "Library for parsing zoneinfo time zone files"
 
-version = "0.1.3"
+version = "0.1.4"
 documentation = "https://docs.rs/zoneinfo_parse"
 homepage = "https://github.com/rust-datetime/zoneinfo-compiled"
 license = "MIT"

From c4f643e96db88dcf50f12315ef7de75cf52420e2 Mon Sep 17 00:00:00 2001
From: Djzin <djzin@users.noreply.github.com>
Date: Sat, 11 Feb 2017 10:52:40 +0000
Subject: [PATCH 069/113] initial commit

---
 .gitignore         |   2 +
 Cargo.toml         |   7 +
 src/.lib.rs.swp    | Bin 0 -> 45056 bytes
 src/lib.rs         |   6 +
 src/line.rs        | 857 +++++++++++++++++++++++++++++++++++++++++++++
 src/structure.rs   | 208 +++++++++++
 src/table.rs       | 375 ++++++++++++++++++++
 src/transitions.rs | 414 ++++++++++++++++++++++
 8 files changed, 1869 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 Cargo.toml
 create mode 100644 src/.lib.rs.swp
 create mode 100644 src/lib.rs
 create mode 100644 src/line.rs
 create mode 100644 src/structure.rs
 create mode 100644 src/table.rs
 create mode 100644 src/transitions.rs

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a9d37c5
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+target
+Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..2c6c0cd
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "parse-zoneinfo"
+version = "0.1.0"
+authors = ["Djzin <djzin@users.noreply.github.com>"]
+
+[dependencies]
+regex = "^0.1"
diff --git a/src/.lib.rs.swp b/src/.lib.rs.swp
new file mode 100644
index 0000000000000000000000000000000000000000..e6738cc6e4b517b71e734a2004aab13eb33b835c
GIT binary patch
literal 45056
zcmeI5eT*Duea9!n2?-4*v{jonRrGkz*mL&1+ZeO<o$J^Rao}Q?v+I|$Ip%if?$)<2
zm)%+07uyAumm=a&2uQ7<sRH>U2@<GDRr&`cq67&jG?4P5Hfq{J5lst1wBS}Mh4%A%
zo@aJucK7T%%MB!bM*8gRJo9_rzVpoNJg+-F^xJ#K)z*O_kL^a!d;Jr?fB3}JW$%Xv
zJ#RLw&CH1VCAQaz-Tqydu=2d$(E$!N>V?6Dpxy}k@2*wDQgx=Loyw)@fqLVTfj9%F
zfKy=Q3N)jc{;e<fHjNDHTfHZ@M*Y$+a+ABwDc}@v3OEIv0!{&^fK$LJ;1u|Oqd>H9
zz4sP!`x2YuvfW?RwttyDUT^ntyFhGry>-9Z?%!$m@%iiQ@eOu=SKIlQ+T+0PPqv-E
z)*i32`?s~7zs4TlZ1<J6^Rd61towA^`8eIbV%^*0x6W?o6mSYS1)Ks-0jGddz$xGq
za0)mDoB~dP7o-9~(eoark{(F~nEwB`{{OvKc;0v6tME8H1oy#Nn1S121a5|3gPY)5
z`0i@Y`vyD$?}a(|O}Ghu@N&=lJUjrWVL$kABV3?i;79N|co5FQVb}(FSPkF*1<!j7
z&O;5VuoKq6Q#4RK4EMmh;W+Gu>)}}%Cmw}&z!B(&tKjQ2N<0o9fe%9&4nrS!@HHAG
z9)`29AJ)PR@NYCm`~aSWN8qh+2zJ0)=z$9~NPH8%03U+~;ePlKd=Tz}01m+GU<+)9
zO>i?@1FPUKX}I_xoPa#M628f`dOy4a?gqJbGq4LT(2(<2Fv9mC7=&xB`*XNI17C*E
z!YAQTcnCfO=ix1I7Zf0XH^V*{fz2?cWV<aWmBZqZFsSdBfgJusR4-L$d;7eF=Clf{
z&5GJnuh;78jOU&6#KZ2e5LTwcdY?YJvvx9dw674=TBjz$g(!7yXLGjMh>Wj0n&rj#
zTQxM_#sllLQ(}?L#HYXYda{eR<b-xf4$ocG4r9q@K7VIZGT<+Ako6$JEhDtVWSJhs
zOg5zSr+WD^I;QGj)T~#Hy7_$jWhhk_n$bX1n`-Fm;rDVyB!u*~Z{B1<LhH;})?V@|
zc9kG1%qck<&;xh;Uao99&|D=rol|F(>`RqqC6|OgZd|ef=PISDu`gBI?Tt%fPl8SS
z>o&CV7c>f`(p0&2Dy$a*%3qwGnW~zp*D8{KUmNGuI==U+{xS8&u+c0>+a=F^Y9cJp
z<nt&yCS_Ez5-l!-qN^G;>TdH&m4&jpjo>KVYKGD*UXvni%R_0)W~*{0r{i%pT6cu?
z-7{GX>!p*S&z%#Mg7Tib`nWr$o3njtS8ZXD&oZN;dXL9<PEu@=Z<5}%xt^ZhfoAno
zJy`I&Txb7S&%lP>9iG^xw_}YBUivt!EJTY_<x(}wBhhSlI-jqGr~G<PPtM<Qx>vo)
z$P;_H%vgQ3WB>MQPzm+(<JiPTMS*Tlio~G}qo6(;Mwqq?H+pdb;{6*+)p-dbdxm_>
zKR=m?N;WejNGEg0()lR{i{`nx4BJYr8qHbjONA?UWE}9NY$?FpM#j1&Yqltev|9gq
zvm7=W!AZGVE!(WnE!){j#OS}aa64_=FI0hSma5GlD%Gm)f{B``O<#nc@dZoWv6E_N
z|4|k6->ruFU#kYyl-j8J)p2_dcV6qGJit2cOd0FB{0qHSUFtz250sg5FgvCuPc@pe
zcOO?>9(FntbG0US$+6;@;l7b`Ja_V@kn<DNj40upNIN$|ie|Cp?4>S?{;Gp)lxC}A
zs(**dz6s1#8dEc+uv}c$qxAXD;|eo##q-j74jwB~crKP2q@LV9cAOvMCCpBR;k*v+
z*s1oQa9%;mFICQ#_!-s3pd3a~SZ`2RCN^H|_sl*@^}|%#b>1^Ny!iRt3U3L!8ih}9
zalA{|m6mBI?>;)jON1BImKU$QgDoe#^b5ffy1bE}qK;>Y{61auSz^>tikE~?*HGlW
zO&sNIjF&`t!_hB=@*c=3{i>HSw)K{dw<Ggj+WwkhT$lPyGiTc$fX21`krBIQO0aQk
zFW1JkT?<nO<E6J*h_d<j!qb%2sw&ijD5NIAyWTcW>i_pr|GtX)xzzvT{_jsvm#;z*
z`r!t6349T|kHQ1+J~#&rsK7j&faCC6um^_Wdbk>N952XL5|?PFfK$LJ;1qBQI0c*n
zP64NYQ@|<kB2d8eDkOaiv}q{a$s;`>NtM|23iNK%wP<S4rD*C@tv=sqb-naVMqwj5
z?p10<CEprUt9vF3Gqb)NUAjL*db#MZ(&0-@JuEjuTWOcWB!O~7pO7RipXYPlm)dx{
z&(e&NoM5QWn!L>C^V#m9xZmg^F-QZ1FO}@2W6)=bK};_rhFz(qa6hUquJNS-buaVc
zZD569fnL9`;q#@@%jQXXWz!<rtWMM_p|Kz-4cavZI@%)!S|RDqG0DBu{{!m(&w|wd
z<MHwTLtXzH@M(Ai?uC2c-4MVy+zJD*8vcv={deHo@K5kG+y^1-g&lAm{Bs=Fi{RFA
zS#SzC1)Ks-0jGddz$xGqa0)mDoB}^L3Ybdbl9gwvX8O`Cy+n<Y%CkO8eNs#>qiQ>`
z5ER0sx=Kw|S4@*$^?_1jN{{X|!!_gjxb3Fb?GSn}=Q{D%r<NGgDQy9L%I}rIoJ)4)
z>!t$v*uFj(vjZk|<z7BgZkg)1<XdXusq^BbYv?IAozK+hXGxHp)@>jw8}BJumo@S7
zTJtz=)7LNOWXuGkTGt1PKK@K+za(tMkxKo4FLm;#ZT&x<KmQ-p>3;-2gnxjq!{^`$
z_!N8+WIn)AI08fP>u?P`M?L?u@E$l1_rNsV4jW)KTp+%$#_|5#+%PU7P64NYQ@|<U
z6mSYS1)Ks-0jGdd;02_B=_r?)qRddst9=VH#cKPmxu7~59*{|ENnO%RF-p}YrNKbF
zGGT%Fym>XD_fn}$JT;@j6f?dWVU$-A-o!#!=%|Or_14R%03T#xSXl!0%~Z{CnGnYu
z$zV~()QWRwwRnJe3$`Y&ePPqpQ`$xcm$piulo<6n97P8`l{t}aMY+*Bnql~{Og72B
zoQmE0wBT~2bF+;>6Dw;lICx-}xi}M1P%Q@aqB%Mgl*_41#1W7MJGJ3xSg-Zz{{K34
z_CE&c|6gT`y3GH77M`@{?q^?ydDsoRz=!qVHm877z$xGqa0)mDoB~b(r+`zyDc}@v
z3cP3(kfxE_SxKb9%1*2s(wNZegf#rpR<l4-_j3$c*eXaP!*cD2XmD^)?Nn87=}6N7
zx223E#Zks*a7wpm#BC2W21x(^pR=ypA*uLN|Bu(-|1$OZKLT0nPuBVS34QjThcW~(
z2}j^C48m`~jj#&-lYaf@;2C%dJ`GR6<M0tU5BI>Ga0~nkYy15voPpi&3iun=^m`EY
zKpr;32n@q@aDjFGz70>qpTK+JJ#a6afifJ0ad<u40b}67w^;k{<8UABgI|V!XT86#
zz{lWSP=s6I7WjMC{FAi+pMo#J7vWQI67Gc6unPW~b^o4*N8$Hi9Dd9iet!l9xCOq1
z&Yyw5fX6`A_IoSH`hIVQqi`7HdK`p(um^U-ufj8|<@dMnBs>fcf!ki33Z$lH#f^5!
zG^lf}b=hotUfZdQ`LGN6U1UMM?qSN~NOgKnMP>Z)nM%9%l%!4$S;{0YAEv2N8}Ol*
zKFgb3_KYlame&gqChogs6%)I7pM;Q&L0krAO4Xu&mUzz6d>k==&8`}xS3vBu5lK3F
z)##|QCzo1OZ?|cHX4S<~y%FuJ?yK*dVLcV!dh4^{j47W02L{SvbvByYIGl`rlO)OZ
zf0V2@1SVCthBWJkU6M6CFhI&k(Lg;s=|8XOic^Em=tDwU>U2p<OXz*|VyPOGMNjRK
zeRBC_b{`ImO*E@RZjcdz>GB{3CK|DkP6QjP&zQq<$f}7_s(S5|M!7KA5+rBUtJG#G
z8bfN`I$iv57#<o@YqCz8t&=CA$R-mcQ<3DAtP&}UP)^rsWfCbi(g}bat93F@ufW2d
z;Z%`A>f51?rpV*Zmeah_Jr_C@TlDo%N2`|P{NnfAlxV*YR7-_5e(u!VA}M4Yq*+$r
zI~k%+u~}|5R56sL&BCH;)OO^uMP!TkKV+8O%I7BnrX*%Ah~(+j8JpYcr49?^Ooeh_
zju)y9n@t&;Lt(KRb{dUjj1Dxrm<(r3kgp@Ap^U{uGizZAmcPhycZ-9YS@LdiP%gec
z()$CGmHy%5I23y+7_YGxR)pY^HX?N(uO_*I+tl!gEM+!1)TcJ}sgXYQ>ON(@^JTbC
zagDcV_sz%61X~G07jS%$XcaW11ZB@j(PuzyMQvA`)EQGc`_=F{J9E}JoXh&D#J55w
zL`q@$!Kh1Xw$$l|8}3_m@w0`1?Aj7&9>k{jkz6q}H>!Q2>ym3+l47kp*z7u0@w40n
z(e{9~(dl<uPn2nU(xuOvNW{Rm&bE6mewJikgm;@~IyqTsuUqo0Xj?wG7R`lqNo9JY
z%qJ`N`b>4Mv7oS7z1JpFuTth~&zS{$ZSv#5a*d{0IF~(2=d^qJj%qK%VvuVDkzQ?=
zy}oJ1TgFq@n>jaAFKKV=yT;Y+{?0{nP3?)jzO~!q>VC`TPK8D7jlH?s@t02G5>J6#
z)C^5@<^iAuN&D;iV8~G}wJ-Kvb4G#1J^8V@!fOz>O6&x`Su0+K*!oVM_}OQ1`l@8b
zZqqO$O*+SM8EW-_Co%raZWGcM%`NvPDTW1odD-i=#BCYWVdV4KwaE1yBsWR5c2av{
z-^EjQ$?}$`TEW~|>}3t}xcJ$aGAo<6{4~M^9T9u8)VV3@)=%34=q+DCb5{Fe&x+_e
zBDq1Vuk<?UEiWgUW$lH%eNyOq%6c)&sZ0I;U#Wv{q24a_f2!VklllMOfv<qH1$+Qx
zEkGIP|6^>w0Dl0pAb!6`7;bY4I0c*nP64NYQ@|<U6mSYS1)Ks-fh(avT&=q@``iiJ
zki?!A6tgAu$vbdOnm^<$f9=$&L|SvRyD}jqQMdlmD~=@>EKsrL&!yOxsL|>zvEM1K
z9ceW_DnY$4*WqJaT-$uigwr|>_Vs2^*I7;CxXrq@c{&l8W+e8ppH!Xv4&$2mxx%eT
zx*mU-e`TfpN(++I|NoFWy{z*m_5Zj#`CA-+CU(CP#n*-56mSYS1)Ks-0jGddz$xGq
za0)mDoB~b(r@&<^U`I^p|6|V#CE`!3&0n%hbBP&hq$~Yq3`Og#)c@~iJpDoG_^1BA
z-lpWI)ct<~UjtbK;4ydr-Uq)6O_&8)`)@C7fwk~T_$lK7{u^YR!1v)v_&B^Bj=~UJ
z3xCI$fydxo@Fv&{FN1$1EuVn%@J@I;ybbE0(|OryIgd^Or+`zyDc}@v3OEIv0!{&^
zz!g^@sd5})5>;D`qcy5rPlHHCu_rSs>;UC>oVM=owI6iJZW>N{RIOz^IJ@0)sKe5Z
z$W9wdk8PJQTjQ`(wqn^CrWt#kGUIFaFlESf)^2IbYS_)PGj_Vm+YOh9U3ZkX*>=y7
z?jY}C*{OWoF)lNa?2I>wedM(r%C{_2;fkf5DI~7;YTADDlwF5PW@eV1@h65%VKQ_5
zeEUZMX7*iPPq@>QmP%VGYI?qsjwUI0tztIHG%b_tR(Zn7<~c4nxY%ou6p&G6vujJj
zsIr;T*LzgG#)K+kDwuz@#T?0X8)YJxC&@RLW|WCw`q1b<%49Kp*phCPxntTTmWb4(
N*7%DvwvtI2{|l-C9TWfn

literal 0
HcmV?d00001

diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..6030c12
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,6 @@
+extern crate regex;
+
+pub mod line;
+pub mod table;
+pub mod transitions;
+pub mod structure;
diff --git a/src/line.rs b/src/line.rs
new file mode 100644
index 0000000..45e05e9
--- /dev/null
+++ b/src/line.rs
@@ -0,0 +1,857 @@
+use std::str::FromStr;
+use std::ascii::AsciiExt;
+
+use regex::{Regex, Captures};
+
+pub struct LineParser {
+    rule_line: Regex,
+    day_field: Regex,
+    hm_field: Regex,
+    hms_field: Regex,
+    zone_line: Regex,
+    continuation_line: Regex,
+    link_line: Regex,
+    empty_line: Regex,
+}
+
+impl LineParser {
+    pub fn new() -> Self {
+        LineParser {
+            rule_line: Regex::new(r##"(?x) ^
+                Rule \s+
+                ( ?P<name>    \S+)  \s+
+                ( ?P<from>    \S+)  \s+
+                ( ?P<to>      \S+)  \s+
+                ( ?P<type>    \S+)  \s+
+                ( ?P<in>      \S+)  \s+
+                ( ?P<on>      \S+)  \s+
+                ( ?P<at>      \S+)  \s+
+                ( ?P<save>    \S+)  \s+
+                ( ?P<letters> \S+)  \s*
+                (\#.*)?
+            $ "##).unwrap(),
+
+            day_field: Regex::new(r##"(?x) ^
+                ( ?P<weekday> \w+ )
+                ( ?P<sign>    [<>] = )
+                ( ?P<day>     \d+ )
+            $ "##).unwrap(),
+
+            hm_field: Regex::new(r##"(?x) ^
+                ( ?P<sign> -? )
+                ( ?P<hour> \d{1,2} ) : ( ?P<minute> \d{2} )
+                ( ?P<flag> [wsugz] )?
+            $ "##).unwrap(),
+
+            hms_field: Regex::new(r##"(?x) ^
+                ( ?P<sign> -? )
+                ( ?P<hour> \d{1,2} ) : ( ?P<minute> \d{2} ) : ( ?P<second> \d{2} )
+                ( ?P<flag> [wsugz] )?
+            $ "##).unwrap(),
+
+            zone_line: Regex::new(r##"(?x) ^
+                Zone \s+
+                ( ?P<name> [ A-Z a-z 0-9 / _ + - ]+ )  \s+
+                ( ?P<gmtoff>     \S+ )  \s+
+                ( ?P<rulessave>  \S+ )  \s+
+                ( ?P<format>     \S+ )  \s*
+                ( ?P<year>       \S+ )? \s*
+                ( ?P<month>      \S+ )? \s*
+                ( ?P<day>        \S+ )? \s*
+                ( ?P<time>       \S+ )? \s*
+                (\#.*)?
+            $ "##).unwrap(),
+
+            continuation_line: Regex::new(r##"(?x) ^
+                \s+
+                ( ?P<gmtoff>     \S+ )  \s+
+                ( ?P<rulessave>  \S+ )  \s+
+                ( ?P<format>     \S+ )  \s*
+                ( ?P<year>       \S+ )? \s*
+                ( ?P<month>      \S+ )? \s*
+                ( ?P<day>        \S+ )? \s*
+                ( ?P<time>       \S+ )? \s*
+                (\#.*)?
+            $ "##).unwrap(),
+
+            link_line: Regex::new(r##"(?x) ^
+                Link  \s+
+                ( ?P<target>  \S+ )  \s+
+                ( ?P<name>    \S+ )  \s*
+                (\#.*)?
+            $ "##).unwrap(),
+
+            empty_line: Regex::new(r##"(?x) ^
+                \s*
+                (\#.*)?
+            $"##).unwrap(),
+        }
+    }
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Year {
+    Minimum,
+    Maximum,
+    Number(i64),
+}
+
+impl FromStr for Year {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Year, Self::Err> {
+        Ok(match &*input.to_ascii_lowercase() {
+            "min" | "minimum" => Year::Minimum,
+            "max" | "maximum" => Year::Maximum,
+            year => match year.parse() {
+                Ok(year) => Year::Number(year),
+                Err(_)   => return Err(Error::FailedYearParse(input.to_string())),
+            }
+        })
+    }
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Month {
+    January = 1,
+    February = 2,
+    March = 3,
+    April = 4,
+    May = 5,
+    June = 6,
+    July = 7,
+    August = 8,
+    September = 9,
+    October = 10,
+    November = 11,
+    December = 12,
+}
+
+impl Month {
+    fn length(self, is_leap: bool) -> i8 {
+        match self {
+            Month::January             => 31,
+            Month::February if is_leap => 29,
+            Month::February            => 28,
+            Month::March               => 31,
+            Month::April               => 30,
+            Month::May                 => 31,
+            Month::June                => 30,
+            Month::July                => 31,
+            Month::August              => 31,
+            Month::September           => 30,
+            Month::October             => 31,
+            Month::November            => 30,
+            Month::December            => 31,
+        }
+    }
+}
+
+#[derive(PartialEq, Debug, Clone)]
+pub enum Error {
+    FailedYearParse(String),
+    FailedMonthParse(String),
+    FailedWeekdayParse(String),
+    InvalidLineType(String),
+    TypeColumnContainedNonHyphen(String),
+    CouldNotParseSaving(String),
+    InvalidDaySpec(String),
+    InvalidTimeSpecAndType(String),
+    NonWallClockInTimeSpec(String),
+    NotParsedAsRuleLine,
+    NotParsedAsZoneLine,
+    NotParsedAsLinkLine,
+}
+
+impl FromStr for Month {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Month, Self::Err> {
+        Ok(match &*input.to_ascii_lowercase() {
+            "jan" | "january"    => Month::January,
+            "feb" | "february"   => Month::February,
+            "mar" | "march"      => Month::March,
+            "apr" | "april"      => Month::April,
+            "may"                => Month::May,
+            "jun" | "june"       => Month::June,
+            "jul" | "july"       => Month::July,
+            "aug" | "august"     => Month::August,
+            "sep" | "september"  => Month::September,
+            "oct" | "october"    => Month::October,
+            "nov" | "november"   => Month::November,
+            "dec" | "december"   => Month::December,
+            other                => return Err(Error::FailedMonthParse(other.to_string())),
+        })
+    }
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Weekday {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+impl FromStr for Weekday {
+    type Err = Error;
+
+    fn from_str(input: &str) -> Result<Weekday, Self::Err> {
+        Ok(match &*input.to_ascii_lowercase() {
+            "mon" | "monday"     => Weekday::Monday,
+            "tue" | "tuesday"    => Weekday::Tuesday,
+            "wed" | "wednesday"  => Weekday::Wednesday,
+            "thu" | "thursday"   => Weekday::Thursday,
+            "fri" | "friday"     => Weekday::Friday,
+            "sat" | "saturday"   => Weekday::Saturday,
+            "sun" | "sunday"     => Weekday::Sunday,
+            other                => return Err(Error::FailedWeekdayParse(other.to_string())),
+        })
+    }
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum DaySpec {
+    Ordinal(i8),
+    Last(Weekday),
+    LastOnOrBefore(Weekday, i8),
+    FirstOnOrAfter(Weekday, i8)
+}
+
+impl Weekday {
+    fn calculate(year: i64, month: Month, day: i8) -> Weekday {
+        let m = month as i64;
+        let y = if m < 3 { year - 1} else { year };
+        let d = day as i64;
+        const T: [i64; 12] = [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4];
+        match (y + y/4 - y/100 + y/400 + T[m as usize-1] + d) % 7 {
+            0 => Weekday::Sunday,
+            1 => Weekday::Monday,
+            2 => Weekday::Tuesday,
+            3 => Weekday::Wednesday,
+            4 => Weekday::Thursday,
+            5 => Weekday::Friday,
+            6 => Weekday::Saturday,
+            _ => panic!("why is negative modulus designed so?")
+        }
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn weekdays() {
+    assert_eq!(Weekday::calculate(1970, Month::January, 1), Weekday::Thursday);
+    assert_eq!(Weekday::calculate(2017, Month::February, 11), Weekday::Saturday);
+    assert_eq!(Weekday::calculate(1890, Month::March, 2), Weekday::Sunday);
+    assert_eq!(Weekday::calculate(2100, Month::April, 20), Weekday::Tuesday);
+    assert_eq!(Weekday::calculate(2009, Month::May, 31), Weekday::Sunday);
+    assert_eq!(Weekday::calculate(2001, Month::June, 9), Weekday::Saturday);
+    assert_eq!(Weekday::calculate(1995, Month::July, 21), Weekday::Friday);
+    assert_eq!(Weekday::calculate(1982, Month::August, 8), Weekday::Sunday);
+    assert_eq!(Weekday::calculate(1962, Month::September, 6), Weekday::Thursday);
+    assert_eq!(Weekday::calculate(1899, Month::October, 14), Weekday::Saturday);
+    assert_eq!(Weekday::calculate(2016, Month::November, 18), Weekday::Friday);
+    assert_eq!(Weekday::calculate(2010, Month::December, 19), Weekday::Sunday);
+    assert_eq!(Weekday::calculate(2016, Month::February, 29), Weekday::Monday);
+}
+
+fn is_leap(year: i64) -> bool {
+    year % 4 == 0 && year % 100 != 0 || year % 400 == 0
+}
+
+#[cfg(test)]
+#[test]
+fn leap_years() {
+    assert!(!is_leap(1900));
+    assert!(is_leap(1904));
+    assert!(is_leap(1964));
+    assert!(is_leap(1996));
+    assert!(!is_leap(1997));
+    assert!(!is_leap(1997));
+    assert!(!is_leap(1999));
+    assert!(is_leap(2000));
+    assert!(is_leap(2016));
+    assert!(!is_leap(2100));
+}
+
+impl DaySpec {
+    pub fn to_concrete_day(&self, year: i64, month: Month) -> i8 {
+        let length = month.length(is_leap(year));
+
+        match *self {
+            DaySpec::Ordinal(day) => day,
+            DaySpec::Last(weekday) => (1..length+1).rev()
+                .find(|&day| Weekday::calculate(year, month, day) == weekday).unwrap(),
+            DaySpec::LastOnOrBefore(weekday, day) => (1..day+1).rev()
+                .find(|&day| Weekday::calculate(year, month, day) == weekday).unwrap(),
+            DaySpec::FirstOnOrAfter(weekday, day) => (day..length+1)
+                .find(|&day| Weekday::calculate(year, month, day) == weekday).unwrap(),
+        }
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn last_monday() {
+    let dayspec = DaySpec::Last(Weekday::Monday);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::January), 25);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::February), 29);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::March), 28);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::April), 25);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::May), 30);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::June), 27);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::July), 25);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::August), 29);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::September), 26);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::October), 31);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::November), 28);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::December), 26);
+}
+
+#[cfg(test)]
+#[test]
+fn first_monday_on_or_after() {
+    let dayspec = DaySpec::FirstOnOrAfter(Weekday::Monday, 20);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::January), 25);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::February), 22);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::March), 21);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::April), 25);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::May), 23);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::June), 20);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::July), 25);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::August), 22);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::September), 26);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::October), 24);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::November), 21);
+    assert_eq!(dayspec.to_concrete_day(2016, Month::December), 26);
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum TimeSpec {
+    Hours(i8),
+    HoursMinutes(i8, i8),
+    HoursMinutesSeconds(i8, i8, i8),
+    Zero,
+}
+
+impl TimeSpec {
+    pub fn as_seconds(self) -> i64 {
+        match self {
+            TimeSpec::Hours(h) => h as i64 * 60 * 60,
+            TimeSpec::HoursMinutes(h, m) => h as i64 * 60 * 60 + m as i64 * 60,
+            TimeSpec::HoursMinutesSeconds(h, m, s) => h as i64 * 60 * 60 + m as i64 * 60 + s as i64,
+            TimeSpec::Zero => 0,
+        }
+    }
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum TimeType {
+    Wall,
+    Standard,
+    UTC,
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct TimeSpecAndType(pub TimeSpec, pub TimeType);
+
+impl TimeSpec {
+    pub fn with_type(self, timetype: TimeType) -> TimeSpecAndType {
+        TimeSpecAndType(self, timetype)
+    }
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum ChangeTime {
+    UntilYear(Year),
+    UntilMonth(Year, Month),
+    UntilDay(Year, Month, DaySpec),
+    UntilTime(Year, Month, DaySpec, TimeSpecAndType),
+}
+
+impl ChangeTime {
+    pub fn to_timestamp(&self) -> i64 {
+
+        fn seconds_in_year(year: i64) -> i64 {
+            if is_leap(year) {
+                366 * 24 * 60 * 60
+            } else {
+                365 * 24 * 60 * 60
+            }
+        }
+
+        fn seconds_until_start_of_year(year: i64) -> i64 {
+            if year >= 1970 {
+                (1970..year).map(seconds_in_year).sum()
+            } else {
+                -(year..1970).map(seconds_in_year).sum::<i64>()
+            }
+        }
+
+        fn time_to_timestamp(year: i64, month: i8, day: i8, hour: i8, minute: i8, second: i8) -> i64 {
+            const MONTHS_NON_LEAP: [i64; 12] = [
+                0,
+                31,
+                31 + 28,
+                31 + 28 + 31,
+                31 + 28 + 31 + 30,
+                31 + 28 + 31 + 30 + 31,
+                31 + 28 + 31 + 30 + 31 + 30,
+                31 + 28 + 31 + 30 + 31 + 30 + 31,
+                31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
+                31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
+                31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
+                31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30
+            ];
+            const MONTHS_LEAP: [i64; 12] = [
+                0,
+                31,
+                31 + 29,
+                31 + 29 + 31,
+                31 + 29 + 31 + 30,
+                31 + 29 + 31 + 30 + 31,
+                31 + 29 + 31 + 30 + 31 + 30,
+                31 + 29 + 31 + 30 + 31 + 30 + 31,
+                31 + 29 + 31 + 30 + 31 + 30 + 31 + 31,
+                31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
+                31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
+                31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30
+            ];
+            seconds_until_start_of_year(year)
+                + 60 * 60 * 24 * if is_leap(year) { MONTHS_LEAP[month as usize - 1] } else { MONTHS_NON_LEAP[month as usize - 1] }
+                + 60 * 60 * 24 * (day as i64 - 1)
+                + 60 * 60 * hour as i64
+                + 60 * minute as i64
+                + second as i64
+        }
+
+        match *self {
+            ChangeTime::UntilYear(Year::Number(y))             => time_to_timestamp(y, 1,                             1, 0, 0,   0),
+            ChangeTime::UntilMonth(Year::Number(y), m)         => time_to_timestamp(y, m as i8,                       1, 0, 0,   0),
+            ChangeTime::UntilDay(Year::Number(y), m, d)        => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), 0, 0,   0),
+            ChangeTime::UntilTime(Year::Number(y), m, d, time) => match time.0 {
+                TimeSpec::Zero                                 => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), 0, 0,   0),
+                TimeSpec::Hours(h)                             => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, 0,   0),
+                TimeSpec::HoursMinutes(h, min)                 => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, min, 0),
+                TimeSpec::HoursMinutesSeconds(h, min, s)       => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, min, s),
+            },
+            _ => unreachable!(),
+        }
+    }
+
+    pub fn year(&self) -> i64 {
+        match *self {
+            ChangeTime::UntilYear(Year::Number(y))      => y,
+            ChangeTime::UntilMonth(Year::Number(y), ..) => y,
+            ChangeTime::UntilDay(Year::Number(y), ..)   => y,
+            ChangeTime::UntilTime(Year::Number(y), ..)  => y,
+            _ => unreachable!()
+        }
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn to_timestamp() {
+    let time = ChangeTime::UntilYear(Year::Number(1970));
+    assert_eq!(time.to_timestamp(), 0);
+    let time = ChangeTime::UntilYear(Year::Number(2016));
+    assert_eq!(time.to_timestamp(), 1451606400);
+    let time = ChangeTime::UntilYear(Year::Number(1900));
+    assert_eq!(time.to_timestamp(), -2208988800);
+    let time = ChangeTime::UntilTime(Year::Number(2000), Month::February, DaySpec::Last(Weekday::Sunday),
+        TimeSpecAndType(TimeSpec::Hours(9), TimeType::Wall));
+    assert_eq!(time.to_timestamp(), 951642000);
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct ZoneInfo<'a> {
+    pub utc_offset: TimeSpec,
+    pub saving: Saving<'a>,
+    pub format: &'a str,
+    pub time: Option<ChangeTime>,
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Saving<'a> {
+    NoSaving,
+    OneOff(TimeSpec),
+    Multiple(&'a str),
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Rule<'a> {
+    pub name: &'a str,
+    pub from_year: Year,
+    pub to_year: Option<Year>,
+    pub month: Month,
+    pub day: DaySpec,
+    pub time: TimeSpecAndType,
+    pub time_to_add: TimeSpec,
+    pub letters: Option<&'a str>,
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Zone<'a> {
+    pub name: &'a str,
+    pub info: ZoneInfo<'a>,
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub struct Link<'a> {
+    pub existing: &'a str,
+    pub new: &'a str,
+}
+
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Line<'a> {
+    Space,
+    Zone(Zone<'a>),
+    Continuation(ZoneInfo<'a>),
+    Rule(Rule<'a>),
+    Link(Link<'a>),
+}
+
+fn parse_time_type(c: &str) -> Option<TimeType> {
+    Some(match c {
+        "w"             => TimeType::Wall,
+        "s"             => TimeType::Standard,
+        "u" | "g" | "z" => TimeType::UTC,
+         _              => return None,
+    })
+}
+
+impl LineParser {
+    fn parse_timespec_and_type(&self, input: &str) -> Result<TimeSpecAndType, Error> {
+        if input == "-" {
+            Ok(TimeSpecAndType(TimeSpec::Zero, TimeType::Wall))
+        }
+        else if input.chars().all(|c| c == '-' || c.is_digit(10)) {
+            Ok(TimeSpecAndType(TimeSpec::Hours(input.parse().unwrap()), TimeType::Wall))
+        }
+        else if let Some(caps) = self.hm_field.captures(input) {
+            let sign   : i8 = if caps.name("sign").unwrap() == "-" { -1 } else { 1 };
+            let hour   : i8 = caps.name("hour").unwrap().parse().unwrap();
+            let minute : i8 = caps.name("minute").unwrap().parse().unwrap();
+            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
+                                          .unwrap_or(TimeType::Wall);
+
+            Ok(TimeSpecAndType(TimeSpec::HoursMinutes(hour * sign, minute * sign), flag))
+        }
+        else if let Some(caps) = self.hms_field.captures(input) {
+            let sign   : i8 = if caps.name("sign").unwrap() == "-" { -1 } else { 1 };
+            let hour   : i8 = caps.name("hour").unwrap().parse().unwrap();
+            let minute : i8 = caps.name("minute").unwrap().parse().unwrap();
+            let second : i8 = caps.name("second").unwrap().parse().unwrap();
+            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
+                                          .unwrap_or(TimeType::Wall);
+
+            Ok(TimeSpecAndType(TimeSpec::HoursMinutesSeconds(hour * sign, minute * sign, second * sign), flag))
+        } else {
+            Err(Error::InvalidTimeSpecAndType(input.to_string()))
+        }
+    }
+
+    fn parse_timespec(&self, input: &str) -> Result<TimeSpec, Error> {
+        match self.parse_timespec_and_type(input) {
+            Ok(TimeSpecAndType(spec, TimeType::Wall)) => Ok(spec),
+            Ok(TimeSpecAndType(_, _)) => Err(Error::NonWallClockInTimeSpec(input.to_string())),
+            Err(e) => Err(e),
+        }
+    }
+
+    fn parse_dayspec(&self, input: &str) -> Result<DaySpec, Error> {
+        if input.chars().all(|c| c.is_digit(10)) {
+            Ok(DaySpec::Ordinal(input.parse().unwrap()))
+        } else if input.starts_with("last") {
+            let weekday = input[4..].parse()?;
+            Ok(DaySpec::Last(weekday))
+        } else if let Some(caps) = self.day_field.captures(input) {
+            let weekday = caps.name("weekday").unwrap().parse().unwrap();
+            let day     = caps.name("day").unwrap().parse().unwrap();
+
+            match caps.name("sign").unwrap() {
+                "<=" => Ok(DaySpec::LastOnOrBefore(weekday, day)),
+                ">=" => Ok(DaySpec::FirstOnOrAfter(weekday, day)),
+                 _   => unreachable!("The regex only matches one of those two!"),
+            }
+        } else {
+            Err(Error::InvalidDaySpec(input.to_string()))
+        }
+    }
+
+    fn parse_rule<'a>(&self, input: &'a str) -> Result<Rule<'a>, Error> {
+        if let Some(caps) = self.rule_line.captures(input) {
+            let name      = caps.name("name").unwrap();
+            let from_year = caps.name("from").unwrap().parse()?;
+
+            // The end year can be ‘only’ to indicate that this rule only
+            // takes place on that year.
+            let to_year = match caps.name("to").unwrap() {
+                "only"  => None,
+                to      => Some(to.parse()?),
+            };
+
+            // According to the spec, the only value inside the ‘type’ column
+            // should be “-”, so throw an error if it isn’t. (It only exists
+            // for compatibility with old versions that used to contain year
+            // types.) Sometimes “‐”, a Unicode hyphen, is used as well.
+            let t = caps.name("type").unwrap();
+            if t != "-" && t != "\u{2010}"  {
+                return Err(Error::TypeColumnContainedNonHyphen(t.to_string()));
+            }
+
+            let month        = caps.name("in").unwrap().parse()?;
+            let day          = self.parse_dayspec(caps.name("on").unwrap())?;
+            let time         = self.parse_timespec_and_type(caps.name("at").unwrap())?;
+            let time_to_add  = self.parse_timespec(caps.name("save").unwrap())?;
+            let letters      = match caps.name("letters").unwrap() {
+                "-"  => None,
+                l    => Some(l),
+            };
+
+            Ok(Rule {
+                name:         name,
+                from_year:    from_year,
+                to_year:      to_year,
+                month:        month,
+                day:          day,
+                time:         time,
+                time_to_add:  time_to_add,
+                letters:      letters,
+            })
+        } else {
+            Err(Error::NotParsedAsRuleLine)
+        }
+    }
+
+    fn saving_from_str<'a>(&self, input: &'a str) -> Result<Saving<'a>, Error> {
+        if input == "-" {
+            Ok(Saving::NoSaving)
+        } else if input.chars().all(|c| c == '-' || c == '_' || c.is_alphabetic()) {
+            Ok(Saving::Multiple(input))
+        } else if self.hm_field.is_match(input) {
+            let time = self.parse_timespec(input)?;
+            Ok(Saving::OneOff(time))
+        } else {
+            Err(Error::CouldNotParseSaving(input.to_string()))
+        }
+    }
+
+    fn zoneinfo_from_captures<'a>(&self, caps: Captures<'a>) -> Result<ZoneInfo<'a>, Error> {
+        let utc_offset = self.parse_timespec(caps.name("gmtoff").unwrap())?;
+        let saving = self.saving_from_str(caps.name("rulessave").unwrap())?;
+        let format = caps.name("format").unwrap();
+
+        let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
+            (Some(y), Some(m), Some(d), Some(t)) => Some(ChangeTime::UntilTime  (y.parse()?, m.parse()?, self.parse_dayspec(d)?, self.parse_timespec_and_type(t)?)),
+            (Some(y), Some(m), Some(d), _      ) => Some(ChangeTime::UntilDay   (y.parse()?, m.parse()?, self.parse_dayspec(d)?)),
+            (Some(y), Some(m), _      , _      ) => Some(ChangeTime::UntilMonth (y.parse()?, m.parse()?)),
+            (Some(y), _      , _      , _      ) => Some(ChangeTime::UntilYear  (y.parse()?)),
+            (None   , None   , None   , None   ) => None,
+            _                                    => unreachable!("Out-of-order capturing groups!"),
+        };
+
+        Ok(ZoneInfo {
+            utc_offset:  utc_offset,
+            saving:      saving,
+            format:      format,
+            time:        time,
+        })
+    }
+
+    fn parse_zone<'a>(&self, input: &'a str) -> Result<Zone<'a>, Error> {
+        if let Some(caps) = self.zone_line.captures(input) {
+            let name = caps.name("name").unwrap();
+            let info = self.zoneinfo_from_captures(caps)?;
+            Ok(Zone {
+                name: name,
+                info: info,
+            })
+        } else {
+            Err(Error::NotParsedAsZoneLine)
+        }
+    }
+
+    fn parse_link<'a>(&self, input: &'a str) -> Result<Link<'a>, Error> {
+        if let Some(caps) = self.link_line.captures(input) {
+            let target  = caps.name("target").unwrap();
+            let name    = caps.name("name").unwrap();
+            Ok(Link { existing: target, new: name })
+        }
+        else {
+            Err(Error::NotParsedAsLinkLine)
+        }
+    }
+
+    pub fn parse_str<'a>(&self, input: &'a str) -> Result<Line<'a>, Error> {
+        if self.empty_line.is_match(input) {
+            return Ok(Line::Space)
+        }
+
+        match self.parse_zone(input) {
+            Err(Error::NotParsedAsZoneLine) => {},
+            result => return result.map(Line::Zone),
+        }
+
+        match self.continuation_line.captures(input) {
+            None => {},
+            Some(caps) => return self.zoneinfo_from_captures(caps).map(Line::Continuation),
+        }
+
+        match self.parse_rule(input) {
+            Err(Error::NotParsedAsRuleLine) => {},
+            result => return result.map(Line::Rule),
+        }
+
+        match self.parse_link(input) {
+            Err(Error::NotParsedAsLinkLine) => {},
+            result => return result.map(Line::Link),
+        }
+        
+        Err(Error::InvalidLineType(input.to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    macro_rules! test {
+        ($name:ident: $input:expr => $result:expr) => {
+            #[test]
+            fn $name() {
+                let parser = LineParser::new();
+                assert_eq!(parser.parse_str($input), $result);
+            }
+        };
+    }
+
+    test!(empty:    ""          => Ok(Line::Space));
+    test!(spaces:   "        "  => Ok(Line::Space));
+
+    test!(rule_1: "Rule  US    1967  1973  ‐     Apr  lastSun  2:00  1:00  D" => Ok(Line::Rule(Rule {
+        name:         "US",
+        from_year:    Year::Number(1967),
+        to_year:      Some(Year::Number(1973)),
+        month:        Month::April,
+        day:          DaySpec::Last(Weekday::Sunday),
+        time:         TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Wall),
+        time_to_add:  TimeSpec::HoursMinutes(1, 0),
+        letters:      Some("D"),
+    })));
+
+    test!(rule_2: "Rule	Greece	1976	only	-	Oct	10	2:00s	0	-" => Ok(Line::Rule(Rule {
+        name:         "Greece",
+        from_year:    Year::Number(1976),
+        to_year:      None,
+        month:        Month::October,
+        day:          DaySpec::Ordinal(10),
+        time:         TimeSpec::HoursMinutes(2, 0).with_type(TimeType::Standard),
+        time_to_add:  TimeSpec::Hours(0),
+        letters:      None,
+    })));
+
+    test!(rule_3: "Rule	EU	1977	1980	-	Apr	Sun>=1	 1:00u	1:00	S" => Ok(Line::Rule(Rule {
+        name:         "EU",
+        from_year:    Year::Number(1977),
+        to_year:      Some(Year::Number(1980)),
+        month:        Month::April,
+        day:          DaySpec::FirstOnOrAfter(Weekday::Sunday, 1),
+        time:         TimeSpec::HoursMinutes(1, 0).with_type(TimeType::UTC),
+        time_to_add:  TimeSpec::HoursMinutes(1, 0),
+        letters:      Some("S"),
+    })));
+
+    test!(no_hyphen: "Rule	EU	1977	1980	HEY	Apr	Sun>=1	 1:00u	1:00	S"         => Err(Error::TypeColumnContainedNonHyphen("HEY".to_string())));
+    test!(bad_month: "Rule	EU	1977	1980	-	Febtober	Sun>=1	 1:00u	1:00	S" => Err(Error::FailedMonthParse("febtober".to_string())));
+
+    test!(zone: "Zone  Australia/Adelaide  9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Ok(Line::Zone(Zone {
+        name: "Australia/Adelaide",
+        info: ZoneInfo {
+            utc_offset:  TimeSpec::HoursMinutes(9, 30),
+            saving:      Saving::Multiple("Aus"),
+            format:      "AC%sT",
+            time:        Some(ChangeTime::UntilTime(Year::Number(1971), Month::October, DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
+        },
+    })));
+
+    test!(continuation_1: "                          9:30    Aus         AC%sT   1971 Oct 31  2:00:00" => Ok(Line::Continuation(ZoneInfo {
+        utc_offset:  TimeSpec::HoursMinutes(9, 30),
+        saving:      Saving::Multiple("Aus"),
+        format:      "AC%sT",
+        time:        Some(ChangeTime::UntilTime(Year::Number(1971), Month::October, DaySpec::Ordinal(31), TimeSpec::HoursMinutesSeconds(2, 0, 0).with_type(TimeType::Wall))),
+    })));
+
+    test!(continuation_2: "			1:00	C-Eur	CE%sT	1943 Oct 25" => Ok(Line::Continuation(ZoneInfo {
+        utc_offset:  TimeSpec::HoursMinutes(1, 00),
+        saving:      Saving::Multiple("C-Eur"),
+        format:      "CE%sT",
+        time:        Some(ChangeTime::UntilDay(Year::Number(1943), Month::October, DaySpec::Ordinal(25))),
+    })));
+
+    test!(zone_hyphen: "Zone Asia/Ust-Nera\t 9:32:54 -\tLMT\t1919" => Ok(Line::Zone(Zone {
+        name: "Asia/Ust-Nera",
+        info: ZoneInfo {
+            utc_offset:  TimeSpec::HoursMinutesSeconds(9, 32, 54),
+            saving:      Saving::NoSaving,
+            format:      "LMT",
+            time:        Some(ChangeTime::UntilYear(Year::Number(1919))),
+        },
+    })));
+
+    #[test]
+    fn negative_offsets() {
+        static LINE: &'static str = "Zone    Europe/London   -0:01:15 -  LMT 1847 Dec  1  0:00s";
+        let parser = LineParser::new();
+        let zone = parser.parse_zone(LINE).unwrap();
+        assert_eq!(zone.info.utc_offset, TimeSpec::HoursMinutesSeconds(0, -1, -15));
+    }
+
+    #[test]
+    fn negative_offsets_2() {
+        static LINE: &'static str = "Zone        Europe/Madrid   -0:14:44 -      LMT     1901 Jan  1  0:00s";
+        let parser = LineParser::new();
+        let zone = parser.parse_zone(LINE).unwrap();
+        assert_eq!(zone.info.utc_offset, TimeSpec::HoursMinutesSeconds(0, -14, -44));
+    }
+
+    #[test]
+    fn negative_offsets_3() {
+        static LINE: &'static str = "Zone America/Danmarkshavn -1:14:40 -    LMT 1916 Jul 28";
+        let parser = LineParser::new();
+        let zone = parser.parse_zone(LINE).unwrap();
+        assert_eq!(zone.info.utc_offset, TimeSpec::HoursMinutesSeconds(-1, -14, -40));
+    }
+
+    test!(link: "Link  Europe/Istanbul  Asia/Istanbul" => Ok(Line::Link(Link {
+        existing:  "Europe/Istanbul",
+        new:       "Asia/Istanbul",
+    })));
+
+    #[test]
+    fn month() {
+        assert_eq!(Month::from_str("Aug"), Ok(Month::August));
+        assert_eq!(Month::from_str("December"), Ok(Month::December));
+    }
+
+    test!(golb: "GOLB" => Err(Error::InvalidLineType("GOLB".to_string())));
+
+    test!(comment: "# this is a comment" => Ok(Line::Space));
+    test!(another_comment: "     # so is this" => Ok(Line::Space));
+    test!(multiple_hash: "     # so is this ## " => Ok(Line::Space));
+    test!(non_comment: " this is not a # comment" => Err(Error::InvalidTimeSpecAndType("this".to_string())));
+
+    test!(comment_after: "Link  Europe/Istanbul  Asia/Istanbul #with a comment after" => Ok(Line::Link(Link {
+        existing:  "Europe/Istanbul",
+        new:       "Asia/Istanbul",
+    })));
+
+    test!(two_comments_after: "Link  Europe/Istanbul  Asia/Istanbul   # comment ## comment" => Ok(Line::Link(Link {
+        existing:  "Europe/Istanbul",
+        new:       "Asia/Istanbul",
+    })));
+}
diff --git a/src/structure.rs b/src/structure.rs
new file mode 100644
index 0000000..73ce7a6
--- /dev/null
+++ b/src/structure.rs
@@ -0,0 +1,208 @@
+//! Determining the structure of a set of ruleset names.
+//!
+//! The names of time zones in the zoneinfo database are of the form
+//! `Area/Location`, or more rarely, `Area/Location/Sublocation`. This means
+//! they form a hierarchy, with each level either serving as a time zone
+//! itself (usually a location) or as a parent of multiple other entries
+//! (usually an area).
+//!
+//! When generating Rust code containing the timezone data, we need to
+//! generate the entire tree structure, not just the leaves of actual timezone
+//! data. This module determines that structure, allowing it to be created
+//! before any actual timezone data is written.
+//!
+//! For example, say we have the following subset of time zone entries:
+//!
+//! - America/Antigua
+//! - America/Araguaina
+//! - America/Argentina/Buenos_Aires
+//! - America/Argentina/Catamarca
+//! - America/Argentina/Cordoba
+//! - America/Aruba
+//!
+//! On top of the six actual time zone files, we would need to create the following:
+//!
+//! - An America module that has three private submodules (Antigua, Araguaína,
+//!   and Aruba) and one public submodule (Argentina);
+//! - An America/Argentina submodule that has there private submodules (Buenos
+//!   Aires, Catamarca, Cordoba).
+//!
+//! This module contains an iterator that finds all parent zonesets, and
+//! sorts them so they’re output in a correct order.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use table::Table;
+
+
+/// Trait to put the `structure` method on Tables.
+pub trait Structure {
+
+    /// Returns an iterator over the structure of this table.
+    fn structure(&self) -> TableStructure;
+}
+
+impl Structure for Table {
+    fn structure(&self) -> TableStructure {
+        let mut mappings = BTreeMap::new();
+
+        for key in self.zonesets.keys().chain(self.links.keys()) {
+
+            // Extract the name from the *last* slash. So
+            // `America/Kentucky/Louisville` is split into
+            // `America/Kentucky` and `Louisville` components.
+            let last_slash = match key.rfind('/') {
+                Some(pos) => pos,
+                None      => continue,
+            };
+
+            // Split the string around the slash, which gets removed.
+            let parent = &key[.. last_slash];
+            {
+                let set = mappings.entry(parent).or_insert_with(BTreeSet::new);
+                set.insert(Child::TimeZone(&key[last_slash + 1 ..]));
+            }
+
+            // If the *parent* name still has a slash in it, then this is
+            // a time zone of the form `America/Kentucky/Louisville`. We
+            // need to make sure that `America` now has a `Kentucky`
+            // child, too.
+            if let Some(first_slash) = parent.find('/') {
+                let grandparent = &parent[.. first_slash];
+                let set = mappings.entry(grandparent).or_insert_with(BTreeSet::new);
+                set.insert(Child::Submodule(&parent[first_slash + 1 ..]));
+            }
+        }
+
+        TableStructure { mappings: mappings }
+    }
+}
+
+
+/// The structure of a set of time zone names.
+#[derive(PartialEq, Debug)]
+pub struct TableStructure<'table> {
+    mappings: BTreeMap<&'table str, BTreeSet<Child<'table>>>,
+}
+
+impl<'table> IntoIterator for TableStructure<'table> {
+    type Item = TableStructureEntry<'table>;
+    type IntoIter = Iter<'table>;
+
+    fn into_iter(self) -> Self::IntoIter {
+
+        // It’s necessary to sort the keys before producing them, to
+        // ensure that (for example) `America` is produced before
+        // `America/Kentucky`.
+        let mut keys: Vec<_> = self.mappings.keys().cloned().collect();
+        keys.sort_by(|a, b| b.cmp(a));
+
+        Iter {
+            structure: self,
+            keys: keys,
+        }
+    }
+}
+
+/// Iterator over sorted entries in a `TableStructure`.
+#[derive(PartialEq, Debug)]
+pub struct Iter<'table> {
+    structure: TableStructure<'table>,
+    keys: Vec<&'table str>,
+}
+
+impl<'table> Iterator for Iter<'table> {
+    type Item = TableStructureEntry<'table>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let key = match self.keys.pop() {
+                Some(k) => k,
+                None    => return None,
+            };
+
+            // Move the strings out into an (automatically-sorted) vector.
+            let values = self.structure.mappings[key].iter().cloned().collect();
+
+            return Some(TableStructureEntry {
+                name: key,
+                children: values,
+            });
+        }
+    }
+}
+
+/// An entry returned from a `TableStructure` iterator.
+#[derive(PartialEq, Debug)]
+pub struct TableStructureEntry<'table> {
+
+    /// This entry’s name, which *can* still include slashes.
+    pub name: &'table str,
+
+    /// A vector of sorted child names, which should have no slashes in.
+    pub children: Vec<Child<'table>>,
+}
+
+/// A child module that needs to be created.
+///
+/// The order here is important for `PartialOrd`: submodules need to be
+/// created before actual time zones, as directories need to be created
+/// before the files in them can be written.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Copy, Clone)]
+pub enum Child<'table> {
+
+    /// A module containing **only** submodules, no time zones.
+    Submodule(&'table str),
+
+    /// A module containing **only** the details of a time zone.
+    TimeZone(&'table str),
+}
+
+
+#[cfg(test)]
+#[allow(unused_results)]
+mod test {
+    use super::*;
+    use table::Table;
+
+    #[test]
+    fn empty() {
+        let table = Table::default();
+        let mut structure = table.structure().into_iter();
+        assert_eq!(structure.next(), None);
+    }
+
+    #[test]
+    fn separate() {
+        let mut table = Table::default();
+        table.zonesets.insert("a".to_owned(), Vec::new());
+        table.zonesets.insert("b".to_owned(), Vec::new());
+        table.zonesets.insert("c".to_owned(), Vec::new());
+
+        let mut structure = table.structure().into_iter();
+        assert_eq!(structure.next(), None);
+    }
+
+    #[test]
+    fn child() {
+        let mut table = Table::default();
+        table.zonesets.insert("a/b".to_owned(), Vec::new());
+
+        let mut structure = table.structure().into_iter();
+        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(), children: vec![ Child::TimeZone("b") ] }));
+        assert_eq!(structure.next(), None);
+    }
+
+    #[test]
+    fn hierarchy() {
+        let mut table = Table::default();
+        table.zonesets.insert("a/b/c".to_owned(), Vec::new());
+        table.zonesets.insert("a/b/d".to_owned(), Vec::new());
+        table.zonesets.insert("a/e".to_owned(),   Vec::new());
+
+        let mut structure = table.structure().into_iter();
+        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(),   children: vec![ Child::Submodule("b"), Child::TimeZone("e") ] }));
+        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a/b".to_owned(), children: vec![ Child::TimeZone("c"),  Child::TimeZone("d") ] }));
+        assert_eq!(structure.next(), None);
+    }
+}
diff --git a/src/table.rs b/src/table.rs
new file mode 100644
index 0000000..f4ff10e
--- /dev/null
+++ b/src/table.rs
@@ -0,0 +1,375 @@
+use std::collections::hash_map::{HashMap, Entry};
+use std::error::Error as ErrorTrait;
+use std::fmt;
+
+use line::{self, Year, Month, DaySpec, ChangeTime, TimeType};
+
+/// A **table** of all the data in one or more zoneinfo files.
+#[derive(PartialEq, Debug, Default)]
+pub struct Table {
+
+    /// Mapping of ruleset names to rulesets.
+    pub rulesets: HashMap<String, Vec<RuleInfo>>,
+
+    /// Mapping of zoneset names to zonesets.
+    pub zonesets: HashMap<String, Vec<ZoneInfo>>,
+
+    /// Mapping of link timezone names, to the names they link to.
+    pub links: HashMap<String, String>,
+}
+
+
+impl Table {
+
+    /// Tries to find the zoneset with the given name by looking it up in
+    /// either the zonesets map or the links map.
+    pub fn get_zoneset(&self, zone_name: &str) -> Option<&[ZoneInfo]> {
+        if self.zonesets.contains_key(zone_name) {
+            Some(&*self.zonesets[zone_name])
+        }
+        else if self.links.contains_key(zone_name) {
+            let target = &self.links[zone_name];
+            Some(&*self.zonesets[&*target])
+        }
+        else {
+            None
+        }
+    }
+}
+
+
+/// An owned rule definition line.
+///
+/// This mimics the `Rule` struct in the `line` module, only its uses owned
+/// Strings instead of string slices, and has had some pre-processing
+/// applied to it.
+#[derive(PartialEq, Debug)]
+pub struct RuleInfo {
+
+    /// The year that this rule *starts* applying.
+    pub from_year: Year,
+
+    /// The year that this rule *finishes* applying, inclusive, or `None` if
+    /// it applies up until the end of this timespan.
+    pub to_year: Option<Year>,
+
+    /// The month it applies on.
+    pub month: Month,
+
+    /// The day it applies on.
+    pub day: DaySpec,
+
+    /// The exact time it applies on.
+    pub time: i64,
+
+    /// The type of time that time is.
+    pub time_type: TimeType,
+
+    /// The amount of time to save.
+    pub time_to_add: i64,
+
+    /// Any extra letters that should be added to this time zone’s
+    /// abbreviation, in place of `%s`.
+    pub letters: Option<String>,
+}
+
+impl<'line> From<line::Rule<'line>> for RuleInfo {
+    fn from(info: line::Rule) -> RuleInfo {
+        RuleInfo {
+            from_year:    info.from_year,
+            to_year:      info.to_year,
+            month:        info.month,
+            day:          info.day,
+            time:         info.time.0.as_seconds(),
+            time_type:    info.time.1,
+            time_to_add:  info.time_to_add.as_seconds(),
+            letters:      info.letters.map(str::to_owned),
+        }
+    }
+}
+
+impl RuleInfo {
+
+    /// Returns whether this rule is in effect during the given year.
+    pub fn applies_to_year(&self, year: i64) -> bool {
+        use line::Year::*;
+
+        match (self.from_year, self.to_year) {
+            (Number(from), None)             => year == from,
+            (Number(from), Some(Maximum))    => year >= from,
+            (Number(from), Some(Number(to))) => year >= from && year <= to,
+            _ => unreachable!(),
+        }
+    }
+
+    pub fn absolute_datetime(&self, year: i64, utc_offset: i64, dst_offset: i64) -> i64 {
+
+        let offset = match self.time_type {
+            TimeType::UTC       => 0,
+            TimeType::Standard  => utc_offset,
+            TimeType::Wall      => utc_offset + dst_offset,
+        };
+
+        let changetime = ChangeTime::UntilDay(Year::Number(year), self.month, self.day);
+        changetime.to_timestamp() + self.time - offset
+    }
+}
+
+
+/// An owned zone definition line.
+///
+/// This struct mimics the `ZoneInfo` struct in the `line` module, *not* the
+/// `Zone` struct, which is the key name in the map—this is just the value.
+///
+/// As with `RuleInfo`, this struct uses owned Strings rather than string
+/// slices.
+#[derive(PartialEq, Debug)]
+pub struct ZoneInfo {
+
+    /// The number of seconds that need to be added to UTC to get the
+    /// standard time in this zone.
+    pub offset: i64,
+
+    /// The name of all the rules that should apply in the time zone, or the
+    /// amount of daylight-saving time to add.
+    pub saving: Saving,
+
+    /// The format for time zone abbreviations.
+    pub format: Format,
+
+    /// The time at which the rules change for this time zone, or `None` if
+    /// these rules are in effect until the end of time (!).
+    pub end_time: Option<ChangeTime>,
+}
+
+impl<'line> From<line::ZoneInfo<'line>> for ZoneInfo {
+    fn from(info: line::ZoneInfo) -> ZoneInfo {
+        ZoneInfo {
+            offset: info.utc_offset.as_seconds(),
+            saving: match info.saving {
+                line::Saving::NoSaving     => Saving::NoSaving,
+                line::Saving::Multiple(s)  => Saving::Multiple(s.to_owned()),
+                line::Saving::OneOff(t)    => Saving::OneOff(t.as_seconds()),
+            },
+            format:   Format::new(info.format),
+            end_time: info.time,
+        }
+    }
+}
+
+
+/// The amount of daylight saving time (DST) to apply to this timespan. This
+/// is a special type for a certain field in a zone line, which can hold
+/// different types of value.
+///
+/// This is the owned version of the `Saving` type in the `line` module.
+#[derive(PartialEq, Debug)]
+pub enum Saving {
+
+    /// Just stick to the base offset.
+    NoSaving,
+
+    /// This amount of time should be saved while this timespan is in effect.
+    /// (This is the equivalent to there being a single one-off rule with the
+    /// given amount of time to save).
+    OneOff(i64),
+
+    /// All rules with the given name should apply while this timespan is in
+    /// effect.
+    Multiple(String),
+}
+
+
+/// The format string to generate a time zone abbreviation from.
+#[derive(PartialEq, Debug, Clone)]
+pub enum Format {
+
+    /// A constant format, which remains the same throughout both standard
+    /// and DST timespans.
+    Constant(String),
+
+    /// An alternate format, such as “PST/PDT”, which changes between
+    /// standard and DST timespans.
+    Alternate {
+
+        /// Abbreviation to use during Standard Time.
+        standard: String,
+
+        /// Abbreviation to use during Summer Time.
+        dst: String,
+    },
+
+    /// A format with a placeholder `%s`, which uses the `letters` field in
+    /// a `RuleInfo` to generate the time zone abbreviation.
+    Placeholder(String),
+}
+
+impl Format {
+
+    /// Convert the template into one of the `Format` variants. This can’t
+    /// fail, as any syntax that doesn’t match one of the two formats will
+    /// just be a ‘constant’ format.
+    pub fn new(template: &str) -> Format {
+        if let Some(pos) = template.find('/') {
+            Format::Alternate {
+                standard:  template[.. pos].to_owned(),
+                dst:       template[pos + 1 ..].to_owned(),
+            }
+        }
+        else if template.contains("%s") {
+            Format::Placeholder(template.to_owned())
+        }
+        else {
+            Format::Constant(template.to_owned())
+        }
+    }
+
+    pub fn format(&self, dst_offset: i64, letters: Option<&String>) -> String {
+        let letters = match letters {
+            Some(l) => &**l,
+            None    => "",
+        };
+
+        match *self {
+            Format::Constant(ref s) => s.clone(),
+            Format::Placeholder(ref s) => s.replace("%s", letters),
+            Format::Alternate { ref standard, .. } if dst_offset == 0 => standard.clone(),
+            Format::Alternate { ref dst, .. } => dst.clone(),
+        }
+    }
+
+    pub fn format_constant(&self) -> String {
+        if let Format::Constant(ref s) = *self {
+            s.clone()
+        }
+        else {
+            panic!("Expected a constant formatting string");
+        }
+    }
+}
+
+
+/// A builder for `Table` values based on various line definitions.
+#[derive(PartialEq, Debug)]
+pub struct TableBuilder {
+
+    /// The table that’s being built up.
+    table: Table,
+
+    /// If the last line was a zone definition, then this holds its name.
+    /// `None` otherwise. This is so continuation lines can be added to the
+    /// same zone as the original zone line.
+    current_zoneset_name: Option<String>,
+}
+
+impl TableBuilder {
+
+    /// Creates a new builder with an empty table.
+    pub fn new() -> TableBuilder {
+        TableBuilder {
+            table: Table::default(),
+            current_zoneset_name: None,
+        }
+    }
+
+    /// Adds a new line describing a zone definition.
+    ///
+    /// Returns an error if there’s already a zone with the same name, or the
+    /// zone refers to a ruleset that hasn’t been defined yet.
+    pub fn add_zone_line<'line>(&mut self, zone_line: line::Zone<'line>) -> Result<(), Error<'line>> {
+        if let line::Saving::Multiple(ruleset_name) = zone_line.info.saving {
+            if !self.table.rulesets.contains_key(ruleset_name) {
+                return Err(Error::UnknownRuleset(ruleset_name));
+            }
+        }
+
+        let mut zoneset = match self.table.zonesets.entry(zone_line.name.to_owned()) {
+            Entry::Occupied(_)  => return Err(Error::DuplicateZone),
+            Entry::Vacant(e)    => e.insert(Vec::new()),
+        };
+
+        zoneset.push(zone_line.info.into());
+        self.current_zoneset_name = Some(zone_line.name.to_owned());
+        Ok(())
+    }
+
+    /// Adds a new line describing the *continuation* of a zone definition.
+    ///
+    /// Returns an error if the builder wasn’t expecting a continuation line
+    /// (meaning, the previous line wasn’t a zone line)
+    pub fn add_continuation_line(&mut self, continuation_line: line::ZoneInfo) -> Result<(), Error> {
+        let mut zoneset = match self.current_zoneset_name {
+            Some(ref name) => self.table.zonesets.get_mut(name).unwrap(),
+            None => return Err(Error::SurpriseContinuationLine),
+        };
+
+        zoneset.push(continuation_line.into());
+        Ok(())
+    }
+
+    /// Adds a new line describing one entry in a ruleset, creating that set
+    /// if it didn’t exist already.
+    pub fn add_rule_line(&mut self, rule_line: line::Rule) -> Result<(), Error> {
+        let ruleset = self.table.rulesets
+                                .entry(rule_line.name.to_owned())
+                                .or_insert_with(Vec::new);
+
+        ruleset.push(rule_line.into());
+        self.current_zoneset_name = None;
+        Ok(())
+    }
+
+    /// Adds a new line linking one zone to another.
+    ///
+    /// Returns an error if there was already a link with that name.
+    pub fn add_link_line<'line>(&mut self, link_line: line::Link<'line>) -> Result<(), Error<'line>> {
+        match self.table.links.entry(link_line.new.to_owned()) {
+            Entry::Occupied(_)  => Err(Error::DuplicateLink(link_line.new)),
+            Entry::Vacant(e)    => {
+                let _ = e.insert(link_line.existing.to_owned());
+                self.current_zoneset_name = None;
+                Ok(())
+            }
+        }
+    }
+
+    /// Returns the table after it’s finished being built.
+    pub fn build(self) -> Table {
+        self.table
+    }
+}
+
+
+/// Something that can go wrong while constructing a `Table`.
+#[derive(PartialEq, Debug, Copy, Clone)]
+pub enum Error<'line> {
+
+    /// A continuation line was passed in, but the previous line wasn’t a zone
+    /// definition line.
+    SurpriseContinuationLine,
+
+    /// A zone definition referred to a ruleset that hadn’t been defined.
+    UnknownRuleset(&'line str),
+
+    /// A link line was passed in, but there’s already a link with that name.
+    DuplicateLink(&'line str),
+
+    /// A zone line was passed in, but there’s already a zone with that name.
+    DuplicateZone,
+}
+
+impl<'line> fmt::Display for Error<'line> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.description())
+    }
+}
+
+impl<'line> ErrorTrait for Error<'line> {
+    fn description(&self) -> &str {
+        "interpretation error"
+    }
+
+    fn cause(&self) -> Option<&ErrorTrait> {
+        None
+    }
+}
diff --git a/src/transitions.rs b/src/transitions.rs
new file mode 100644
index 0000000..c318684
--- /dev/null
+++ b/src/transitions.rs
@@ -0,0 +1,414 @@
+//! Generating timespan sets from a built Table.
+//!
+//! Once a table has been fully built, it needs to be turned into several
+//! *fixed timespan sets*: a series of spans of time where the local time
+//! offset remains the same throughout. One set is generated for each named
+//! time zone. These timespan sets can then be iterated over to produce
+//! *transitions*: when the local time changes from one offset to another.
+//!
+//! These sets are returned as `FixedTimespanSet` values, rather than
+//! iterators, because the generation logic does not output the timespans
+//! in any particular order, meaning they need to be sorted before they’re
+//! returned—so we may as well just return the vector, rather than an
+//! iterator over the vector.
+//!
+//! Similarly, there is a fixed set of years that is iterated over
+//! (currently 1800..2100), rather than having an iterator that produces
+//! timespans indefinitely. Not only do we need a complete set of timespans
+//! for sorting, but it is not necessarily advisable to rely on offset
+//! changes so far into the future!
+//!
+//! ### Example
+//!
+//! The complete definition of the `Indian/Mauritius` time zone, as
+//! specified in the `africa` file in my version of the tz database, has
+//! two Zone definitions, one of which refers to four Rule definitions:
+//!
+//! ```tz
+//! # Rule      NAME    FROM    TO      TYPE    IN      ON      AT      SAVE    LETTER/S
+//! Rule Mauritius      1982    only    -       Oct     10      0:00    1:00    S
+//! Rule Mauritius      1983    only    -       Mar     21      0:00    0       -
+//! Rule Mauritius      2008    only    -       Oct     lastSun 2:00    1:00    S
+//! Rule Mauritius      2009    only    -       Mar     lastSun 2:00    0       -
+//!
+//! # Zone      NAME            GMTOFF  RULES   FORMAT  [UNTIL]
+//! Zone Indian/Mauritius       3:50:00 -       LMT     1907   # Port Louis
+//!                             4:00 Mauritius  MU%sT          # Mauritius Time
+//! ```
+//!
+//! To generate a fixed timespan set for this timezone, we examine each of the
+//! Zone definitions, generating at least one timespan for each definition.
+//!
+//! * The first timespan describes the *local mean time* (LMT) in Mauritius,
+//!   calculated by the geographical position of Port Louis, its capital.
+//!   Although it’s common to have a timespan set begin with a city’s local mean
+//!   time, it is by no means necessary. This timespan has a fixed offset of
+//!   three hours and fifty minutes ahead of UTC, and lasts until the beginning
+//!   of 1907, at which point the second timespan kicks in.
+//! * The second timespan has no ‘until’ date, so it’s in effect indefinitely.
+//!   Instead of having a fixed offset, it refers to the set of rules under the
+//!   name “Mauritius”, which we’ll have to consult to compute the timespans.
+//!     * The first two rules refer to a summer time transition that began on
+//!       the 10th of October 1982, and lasted until the 21st of March 1983. But
+//!       before we get onto that, we need to add a timespan beginning at the
+//!       time the last one ended (1907), up until the point Summer Time kicks
+//!       in (1982), reflecting that it was four hours ahead of UTC.
+//!     * After this, we add another timespan for Summer Time, when Mauritius
+//!       was an extra hour ahead, bringing the total offset for that time to
+//!       *five* hours.
+//!     * The next (and last) two rules refer to another summer time
+//!       transition from the last Sunday of October 2008 to the last Sunday of
+//!       March 2009, this time at 2am local time instead of midnight. But, as
+//!       before, we need to add a *standard* time timespan beginning at the
+//!       time Summer Time ended (1983) up until the point the next span of
+//!       Summer Time kicks in (2008), again reflecting that it was four hours
+//!       ahead of UTC again.
+//!     * Next, we add the Summer Time timespan, again bringing the total
+//!       offset to five hours. We need to calculate when the last Sundays of
+//!       the months are to get the dates correct.
+//!     * Finally, we add one last standard time timespan, lasting from 2009
+//!       indefinitely, as the Mauritian authorities decided not to change to
+//!       Summer Time again.
+//!
+//! All this calculation results in the following six timespans to be added:
+//!
+//! | Timespan start            | Abbreviation | UTC offset         | DST? |
+//! |:--------------------------|:-------------|:-------------------|:-----|
+//! | *no start*                | LMT          | 3 hours 50 minutes | No   |
+//! | 1906-11-31 T 20:10:00 UTC | MUT          | 4 hours            | No   |
+//! | 1982-09-09 T 20:00:00 UTC | MUST         | 5 hours            | Yes  |
+//! | 1983-02-20 T 19:00:00 UTC | MUT          | 4 hours            | No   |
+//! | 2008-09-25 T 22:00:00 UTC | MUST         | 5 hours            | Yes  |
+//! | 2009-02-28 T 21:00:00 UTC | MUT          | 4 hours            | No   |
+//!
+//! There are a few final things of note:
+//!
+//! Firstly, this library records the times that timespans *begin*, while
+//! the tz data files record the times that timespans *end*. Pay attention to
+//! this if the timestamps aren’t where you expect them to be! For example, in
+//! the data file, the first zone rule has an ‘until’ date and the second has
+//! none, whereas in the list of timespans, the last timespan has a ‘start’
+//! date and the *first* has none.
+//!
+//! Secondly, although local mean time in Mauritius lasted until 1907, the
+//! timespan is recorded as ending in 1906! Why is this? It’s because the
+//! transition occurred at midnight *at the local time*, which in this case,
+//! was three hours fifty minutes ahead of UTC. So that time has to be
+//! *subtracted* from the date, resulting in twenty hours and ten minutes on
+//! the last day of the year. Similar things happen on the rest of the
+//! transitions, being either four or five hours ahead of UTC.
+//!
+//! The logic in this file is based off of `zic.c`, which comes with the
+//! zoneinfo files and is in the public domain.
+
+use table::{Table, Saving, RuleInfo, ZoneInfo};
+
+
+/// A set of timespans, separated by the instances at which the timespans
+/// change over. There will always be one more timespan than transitions.
+///
+/// This mimics the `FixedTimespanSet` struct in `datetime::cal::zone`,
+/// except it uses owned `Vec`s instead of slices.
+#[derive(PartialEq, Debug, Clone)]
+pub struct FixedTimespanSet {
+
+    /// The first timespan, which is assumed to have been in effect up until
+    /// the initial transition instant (if any). Each set has to have at
+    /// least one timespan.
+    pub first: FixedTimespan,
+
+    /// The rest of the timespans, as a vector of tuples, each containing:
+    ///
+    /// 1. A transition instant at which the previous timespan ends and the
+    ///    next one begins, stored as a Unix timestamp;
+    /// 2. The actual timespan to transition into.
+    pub rest: Vec<(i64, FixedTimespan)>,
+}
+
+
+/// An individual timespan with a fixed offset.
+///
+/// This mimics the `FixedTimespan` struct in `datetime::cal::zone`, except
+/// instead of “total offset” and “is DST” fields, it has separate UTC and
+/// DST fields. Also, the name is an owned `String` here instead of a slice.
+#[derive(PartialEq, Debug, Clone)]
+pub struct FixedTimespan {
+
+    /// The number of seconds offset from UTC during this timespan.
+    pub utc_offset: i64,
+
+    /// The number of *extra* daylight-saving seconds during this timespan.
+    pub dst_offset: i64,
+
+    /// The abbreviation in use during this timespan.
+    pub name: String,
+}
+
+impl FixedTimespan {
+
+    /// The total offset in effect during this timespan.
+    pub fn total_offset(&self) -> i64 {
+        self.utc_offset + self.dst_offset
+    }
+}
+
+
+/// Trait to put the `timespans` method on Tables.
+pub trait TableTransitions {
+
+    /// Computes a fixed timespan set for the timezone with the given name.
+    /// Returns `None` if the table doesn’t contain a time zone with that name.
+    fn timespans(&self, zone_name: &str) -> Option<FixedTimespanSet>;
+}
+
+
+impl TableTransitions for Table {
+
+    fn timespans(&self, zone_name: &str) -> Option<FixedTimespanSet> {
+        let mut builder = FixedTimespanSetBuilder::default();
+
+        let zoneset = match self.get_zoneset(zone_name) {
+            Some(zones) => zones,
+            None => return None,
+        };
+
+        for (i, zone_info) in zoneset.iter().enumerate() {
+            let mut dst_offset = 0;
+            let use_until      = i != zoneset.len() - 1;
+            let utc_offset     = zone_info.offset;
+
+            let mut insert_start_transition = i > 0;
+            let mut start_zone_id = None;
+            let mut start_utc_offset = zone_info.offset;
+            let mut start_dst_offset = 0;
+
+            match zone_info.saving {
+                Saving::NoSaving => {
+                    builder.add_fixed_saving(zone_info, 0, &mut dst_offset, utc_offset, &mut insert_start_transition, &mut start_zone_id);
+                },
+
+                Saving::OneOff(amount) => {
+                    builder.add_fixed_saving(zone_info, amount, &mut dst_offset, utc_offset, &mut insert_start_transition, &mut start_zone_id);
+                },
+
+                Saving::Multiple(ref rules) => {
+                    let rules = &self.rulesets[&*rules];
+                    builder.add_multiple_saving(zone_info, &*rules, &mut dst_offset, use_until, utc_offset, &mut insert_start_transition, &mut start_zone_id, &mut start_utc_offset, &mut start_dst_offset);
+                }
+            }
+
+            if insert_start_transition && start_zone_id.is_some() {
+                let t = (builder.start_time.expect("Start time"), FixedTimespan {
+                    utc_offset: start_utc_offset,
+                    dst_offset: start_dst_offset,
+                    name:       start_zone_id.clone().expect("Start zone ID"),
+                });
+                builder.rest.push(t);
+            }
+
+            if use_until {
+                builder.start_time = Some(zone_info.end_time.expect("End time").to_timestamp() - utc_offset - dst_offset);
+            }
+        }
+
+        Some(builder.build())
+    }
+}
+
+#[derive(Debug, Default)]
+struct FixedTimespanSetBuilder {
+    first: Option<FixedTimespan>,
+    rest: Vec<(i64, FixedTimespan)>,
+
+    start_time: Option<i64>,
+    until_time: Option<i64>,
+}
+
+impl FixedTimespanSetBuilder {
+    fn add_fixed_saving(&mut self, timespan: &ZoneInfo, amount: i64,
+            dst_offset: &mut i64, utc_offset: i64, insert_start_transition: &mut bool,
+            start_zone_id: &mut Option<String>)
+    {
+        *dst_offset = amount;
+        *start_zone_id = Some(timespan.format.format(*dst_offset, None));
+
+        if *insert_start_transition {
+            let time = self.start_time.unwrap();
+            let timespan = FixedTimespan {
+                utc_offset: timespan.offset,
+                dst_offset: *dst_offset,
+                name:       start_zone_id.clone().unwrap_or("".to_owned()),
+            };
+
+            self.rest.push((time, timespan));
+            *insert_start_transition = false;
+        }
+        else {
+            self.first = Some(FixedTimespan {
+                utc_offset: utc_offset,
+                dst_offset: *dst_offset,
+                name:       start_zone_id.clone().unwrap_or("".to_owned()),
+            });
+        }
+    }
+
+    #[allow(unused_results)]
+    fn add_multiple_saving(&mut self, timespan: &ZoneInfo, rules: &[RuleInfo],
+            dst_offset: &mut i64, use_until: bool, utc_offset: i64, insert_start_transition: &mut bool,
+            start_zone_id: &mut Option<String>, start_utc_offset: &mut i64, start_dst_offset: &mut i64)
+    {
+        use std::mem::replace;
+
+        for year in 1800..2100 {
+            if use_until && year > timespan.end_time.unwrap().year() {
+                break;
+            }
+
+            let mut activated_rules = rules.iter()
+                                           .filter(|r| r.applies_to_year(year))
+                                           .collect::<Vec<_>>();
+
+            loop {
+                if use_until {
+                    self.until_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - *dst_offset);
+                }
+
+                // Find the minimum rule based on the current UTC and DST offsets.
+                // (this can be replaced with min_by when it stabilises):
+                //.min_by(|r| r.1.absolute_datetime(year, utc_offset, dst_offset));
+                let pos = {
+                    let earliest = activated_rules.iter().enumerate()
+                        .map(|(i, r)| (r.absolute_datetime(year, utc_offset, *dst_offset), i))
+                        .min()
+                        .map(|(_, i)| i);
+
+                    match earliest {
+                        Some(p) => p,
+                        None    => break,
+                    }
+                };
+
+                let earliest_rule = activated_rules.remove(pos);
+                let earliest_at = earliest_rule.absolute_datetime(year, utc_offset, *dst_offset);
+
+                if use_until && earliest_at >= self.until_time.unwrap() {
+                    break;
+                }
+
+                *dst_offset = earliest_rule.time_to_add;
+
+                if *insert_start_transition && earliest_at == self.start_time.unwrap() {
+                    *insert_start_transition = false;
+                }
+
+                if *insert_start_transition {
+                    if earliest_at < self.start_time.unwrap() {
+                        replace(start_utc_offset, timespan.offset);
+                        replace(start_dst_offset, *dst_offset);
+                        replace(start_zone_id, Some(timespan.format.format(*dst_offset, earliest_rule.letters.as_ref())));
+                        continue;
+                    }
+
+                    if start_zone_id.is_none() && *start_utc_offset + *start_dst_offset == timespan.offset + *dst_offset {
+                        replace(start_zone_id, Some(timespan.format.format(*dst_offset, earliest_rule.letters.as_ref())));
+                    }
+                }
+
+                let t = (earliest_at, FixedTimespan {
+                    utc_offset: timespan.offset,
+                    dst_offset: earliest_rule.time_to_add,
+                    name:       timespan.format.format(earliest_rule.time_to_add, earliest_rule.letters.as_ref()),
+                });
+                self.rest.push(t);
+            }
+        }
+
+    }
+
+    fn build(mut self) -> FixedTimespanSet {
+        self.rest.sort_by(|a, b| a.0.cmp(&b.0));
+
+        let first = match self.first {
+            Some(ft) => ft,
+            None     => self.rest.iter().find(|t| t.1.dst_offset == 0).unwrap().1.clone(),
+        };
+
+        let mut zoneset = FixedTimespanSet {
+            first: first,
+            rest:  self.rest,
+        };
+        optimise(&mut zoneset);
+        zoneset
+    }
+}
+
+#[allow(unused_results)]  // for remove
+fn optimise(transitions: &mut FixedTimespanSet) {
+    let mut from_i = 0;
+    let mut to_i = 0;
+
+    while from_i < transitions.rest.len() {
+        if to_i > 1 {
+            let from = transitions.rest[from_i].0;
+            let to = transitions.rest[to_i - 1].0;
+            if from + transitions.rest[to_i - 1].1.total_offset() <= to + transitions.rest[to_i - 2].1.total_offset() {
+                transitions.rest[to_i - 1].1 = transitions.rest[from_i].1.clone();
+                from_i += 1;
+                continue;
+            }
+        }
+
+        if to_i == 0 || transitions.rest[to_i - 1].1 != transitions.rest[from_i].1 {
+            transitions.rest[to_i] = transitions.rest[from_i].clone();
+            to_i += 1;
+        }
+
+        from_i += 1
+    }
+
+    transitions.rest.truncate(to_i);
+
+    if !transitions.rest.is_empty() && transitions.first == transitions.rest[0].1 {
+        transitions.rest.remove(0);
+    }
+}
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use super::optimise;
+
+    // Allow unused results in test code, because the only ‘results’ that
+    // we need to ignore are the ones from inserting and removing from
+    // tables and vectors. And as we set them up ourselves, they’re bound
+    // to be correct, otherwise the tests would fail!
+    #[test]
+    #[allow(unused_results)]
+    fn optimise_macquarie() {
+        let mut transitions = FixedTimespanSet {
+            first: FixedTimespan { utc_offset:     0, dst_offset:    0, name:  "zzz".to_owned() },
+            rest: vec![
+                (-2_214_259_200, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (-1_680_508_800, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+                (-1_669_892_400, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),  // gets removed
+                (-1_665_392_400, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (-1_601_719_200, FixedTimespan { utc_offset:     0,  dst_offset:    0,  name:  "zzz".to_owned() }),
+                (  -687_052_800, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (   -94_730_400, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),  // also gets removed
+                (   -71_136_000, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+                (   -55_411_200, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (   -37_267_200, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+                (   -25_776_000, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
+                (    -5_817_600, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+            ],
+        };
+
+        let mut result = transitions.clone();
+        result.rest.remove(6);
+        result.rest.remove(2);
+
+        optimise(&mut transitions);
+        assert_eq!(transitions, result);
+    }
+}

From 1958927b150055b97d5b06698fd1722fb4b4b238 Mon Sep 17 00:00:00 2001
From: Djzin <djzin@users.noreply.github.com>
Date: Sat, 11 Feb 2017 11:09:16 +0000
Subject: [PATCH 070/113] add README and LICENSE

---
 .gitignore      |   1 +
 Cargo.toml      |   5 +++++
 LICENSE         |  21 +++++++++++++++++++++
 README.md       |   6 ++++++
 src/.lib.rs.swp | Bin 45056 -> 0 bytes
 src/line.rs     |  32 ++++++++++++++++----------------
 6 files changed, 49 insertions(+), 16 deletions(-)
 create mode 100644 LICENSE
 create mode 100644 README.md
 delete mode 100644 src/.lib.rs.swp

diff --git a/.gitignore b/.gitignore
index a9d37c5..d4f917d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 target
 Cargo.lock
+*.swp
diff --git a/Cargo.toml b/Cargo.toml
index 2c6c0cd..ff7c149 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,6 +2,11 @@
 name = "parse-zoneinfo"
 version = "0.1.0"
 authors = ["Djzin <djzin@users.noreply.github.com>"]
+description = "Parse zoneinfo files from the IANA database"
+keywords = ["date", "time", "timezone", "zone", "calendar"]
+repository = "https://github.com/djzin/parse-zoneinfo"
+readme = "README.md"
+license = "MIT"
 
 [dependencies]
 regex = "^0.1"
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..3e15ab0
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+Copyright (c) 2017 Djzin
+
+The MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c651147
--- /dev/null
+++ b/README.md
@@ -0,0 +1,6 @@
+# parse-zoneinfo
+
+Parse-zoneinfo is a fork of [`zoneinfo_parse`][zoneinfo_parse], with adjustments such that it no longer depends on the `Datetime` crate. It is used by [`chrono-tz`][chrono_tz].
+
+[zoneinfo_parse]: https://github.com/rust-datetime/zoneinfo-parse
+[chrono_tz]: https://github.com/djzin/chrono-tz
diff --git a/src/.lib.rs.swp b/src/.lib.rs.swp
deleted file mode 100644
index e6738cc6e4b517b71e734a2004aab13eb33b835c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 45056
zcmeI5eT*Duea9!n2?-4*v{jonRrGkz*mL&1+ZeO<o$J^Rao}Q?v+I|$Ip%if?$)<2
zm)%+07uyAumm=a&2uQ7<sRH>U2@<GDRr&`cq67&jG?4P5Hfq{J5lst1wBS}Mh4%A%
zo@aJucK7T%%MB!bM*8gRJo9_rzVpoNJg+-F^xJ#K)z*O_kL^a!d;Jr?fB3}JW$%Xv
zJ#RLw&CH1VCAQaz-Tqydu=2d$(E$!N>V?6Dpxy}k@2*wDQgx=Loyw)@fqLVTfj9%F
zfKy=Q3N)jc{;e<fHjNDHTfHZ@M*Y$+a+ABwDc}@v3OEIv0!{&^fK$LJ;1u|Oqd>H9
zz4sP!`x2YuvfW?RwttyDUT^ntyFhGry>-9Z?%!$m@%iiQ@eOu=SKIlQ+T+0PPqv-E
z)*i32`?s~7zs4TlZ1<J6^Rd61towA^`8eIbV%^*0x6W?o6mSYS1)Ks-0jGddz$xGq
za0)mDoB~dP7o-9~(eoark{(F~nEwB`{{OvKc;0v6tME8H1oy#Nn1S121a5|3gPY)5
z`0i@Y`vyD$?}a(|O}Ghu@N&=lJUjrWVL$kABV3?i;79N|co5FQVb}(FSPkF*1<!j7
z&O;5VuoKq6Q#4RK4EMmh;W+Gu>)}}%Cmw}&z!B(&tKjQ2N<0o9fe%9&4nrS!@HHAG
z9)`29AJ)PR@NYCm`~aSWN8qh+2zJ0)=z$9~NPH8%03U+~;ePlKd=Tz}01m+GU<+)9
zO>i?@1FPUKX}I_xoPa#M628f`dOy4a?gqJbGq4LT(2(<2Fv9mC7=&xB`*XNI17C*E
z!YAQTcnCfO=ix1I7Zf0XH^V*{fz2?cWV<aWmBZqZFsSdBfgJusR4-L$d;7eF=Clf{
z&5GJnuh;78jOU&6#KZ2e5LTwcdY?YJvvx9dw674=TBjz$g(!7yXLGjMh>Wj0n&rj#
zTQxM_#sllLQ(}?L#HYXYda{eR<b-xf4$ocG4r9q@K7VIZGT<+Ako6$JEhDtVWSJhs
zOg5zSr+WD^I;QGj)T~#Hy7_$jWhhk_n$bX1n`-Fm;rDVyB!u*~Z{B1<LhH;})?V@|
zc9kG1%qck<&;xh;Uao99&|D=rol|F(>`RqqC6|OgZd|ef=PISDu`gBI?Tt%fPl8SS
z>o&CV7c>f`(p0&2Dy$a*%3qwGnW~zp*D8{KUmNGuI==U+{xS8&u+c0>+a=F^Y9cJp
z<nt&yCS_Ez5-l!-qN^G;>TdH&m4&jpjo>KVYKGD*UXvni%R_0)W~*{0r{i%pT6cu?
z-7{GX>!p*S&z%#Mg7Tib`nWr$o3njtS8ZXD&oZN;dXL9<PEu@=Z<5}%xt^ZhfoAno
zJy`I&Txb7S&%lP>9iG^xw_}YBUivt!EJTY_<x(}wBhhSlI-jqGr~G<PPtM<Qx>vo)
z$P;_H%vgQ3WB>MQPzm+(<JiPTMS*Tlio~G}qo6(;Mwqq?H+pdb;{6*+)p-dbdxm_>
zKR=m?N;WejNGEg0()lR{i{`nx4BJYr8qHbjONA?UWE}9NY$?FpM#j1&Yqltev|9gq
zvm7=W!AZGVE!(WnE!){j#OS}aa64_=FI0hSma5GlD%Gm)f{B``O<#nc@dZoWv6E_N
z|4|k6->ruFU#kYyl-j8J)p2_dcV6qGJit2cOd0FB{0qHSUFtz250sg5FgvCuPc@pe
zcOO?>9(FntbG0US$+6;@;l7b`Ja_V@kn<DNj40upNIN$|ie|Cp?4>S?{;Gp)lxC}A
zs(**dz6s1#8dEc+uv}c$qxAXD;|eo##q-j74jwB~crKP2q@LV9cAOvMCCpBR;k*v+
z*s1oQa9%;mFICQ#_!-s3pd3a~SZ`2RCN^H|_sl*@^}|%#b>1^Ny!iRt3U3L!8ih}9
zalA{|m6mBI?>;)jON1BImKU$QgDoe#^b5ffy1bE}qK;>Y{61auSz^>tikE~?*HGlW
zO&sNIjF&`t!_hB=@*c=3{i>HSw)K{dw<Ggj+WwkhT$lPyGiTc$fX21`krBIQO0aQk
zFW1JkT?<nO<E6J*h_d<j!qb%2sw&ijD5NIAyWTcW>i_pr|GtX)xzzvT{_jsvm#;z*
z`r!t6349T|kHQ1+J~#&rsK7j&faCC6um^_Wdbk>N952XL5|?PFfK$LJ;1qBQI0c*n
zP64NYQ@|<kB2d8eDkOaiv}q{a$s;`>NtM|23iNK%wP<S4rD*C@tv=sqb-naVMqwj5
z?p10<CEprUt9vF3Gqb)NUAjL*db#MZ(&0-@JuEjuTWOcWB!O~7pO7RipXYPlm)dx{
z&(e&NoM5QWn!L>C^V#m9xZmg^F-QZ1FO}@2W6)=bK};_rhFz(qa6hUquJNS-buaVc
zZD569fnL9`;q#@@%jQXXWz!<rtWMM_p|Kz-4cavZI@%)!S|RDqG0DBu{{!m(&w|wd
z<MHwTLtXzH@M(Ai?uC2c-4MVy+zJD*8vcv={deHo@K5kG+y^1-g&lAm{Bs=Fi{RFA
zS#SzC1)Ks-0jGddz$xGqa0)mDoB}^L3Ybdbl9gwvX8O`Cy+n<Y%CkO8eNs#>qiQ>`
z5ER0sx=Kw|S4@*$^?_1jN{{X|!!_gjxb3Fb?GSn}=Q{D%r<NGgDQy9L%I}rIoJ)4)
z>!t$v*uFj(vjZk|<z7BgZkg)1<XdXusq^BbYv?IAozK+hXGxHp)@>jw8}BJumo@S7
zTJtz=)7LNOWXuGkTGt1PKK@K+za(tMkxKo4FLm;#ZT&x<KmQ-p>3;-2gnxjq!{^`$
z_!N8+WIn)AI08fP>u?P`M?L?u@E$l1_rNsV4jW)KTp+%$#_|5#+%PU7P64NYQ@|<U
z6mSYS1)Ks-0jGdd;02_B=_r?)qRddst9=VH#cKPmxu7~59*{|ENnO%RF-p}YrNKbF
zGGT%Fym>XD_fn}$JT;@j6f?dWVU$-A-o!#!=%|Or_14R%03T#xSXl!0%~Z{CnGnYu
z$zV~()QWRwwRnJe3$`Y&ePPqpQ`$xcm$piulo<6n97P8`l{t}aMY+*Bnql~{Og72B
zoQmE0wBT~2bF+;>6Dw;lICx-}xi}M1P%Q@aqB%Mgl*_41#1W7MJGJ3xSg-Zz{{K34
z_CE&c|6gT`y3GH77M`@{?q^?ydDsoRz=!qVHm877z$xGqa0)mDoB~b(r+`zyDc}@v
z3cP3(kfxE_SxKb9%1*2s(wNZegf#rpR<l4-_j3$c*eXaP!*cD2XmD^)?Nn87=}6N7
zx223E#Zks*a7wpm#BC2W21x(^pR=ypA*uLN|Bu(-|1$OZKLT0nPuBVS34QjThcW~(
z2}j^C48m`~jj#&-lYaf@;2C%dJ`GR6<M0tU5BI>Ga0~nkYy15voPpi&3iun=^m`EY
zKpr;32n@q@aDjFGz70>qpTK+JJ#a6afifJ0ad<u40b}67w^;k{<8UABgI|V!XT86#
zz{lWSP=s6I7WjMC{FAi+pMo#J7vWQI67Gc6unPW~b^o4*N8$Hi9Dd9iet!l9xCOq1
z&Yyw5fX6`A_IoSH`hIVQqi`7HdK`p(um^U-ufj8|<@dMnBs>fcf!ki33Z$lH#f^5!
zG^lf}b=hotUfZdQ`LGN6U1UMM?qSN~NOgKnMP>Z)nM%9%l%!4$S;{0YAEv2N8}Ol*
zKFgb3_KYlame&gqChogs6%)I7pM;Q&L0krAO4Xu&mUzz6d>k==&8`}xS3vBu5lK3F
z)##|QCzo1OZ?|cHX4S<~y%FuJ?yK*dVLcV!dh4^{j47W02L{SvbvByYIGl`rlO)OZ
zf0V2@1SVCthBWJkU6M6CFhI&k(Lg;s=|8XOic^Em=tDwU>U2p<OXz*|VyPOGMNjRK
zeRBC_b{`ImO*E@RZjcdz>GB{3CK|DkP6QjP&zQq<$f}7_s(S5|M!7KA5+rBUtJG#G
z8bfN`I$iv57#<o@YqCz8t&=CA$R-mcQ<3DAtP&}UP)^rsWfCbi(g}bat93F@ufW2d
z;Z%`A>f51?rpV*Zmeah_Jr_C@TlDo%N2`|P{NnfAlxV*YR7-_5e(u!VA}M4Yq*+$r
zI~k%+u~}|5R56sL&BCH;)OO^uMP!TkKV+8O%I7BnrX*%Ah~(+j8JpYcr49?^Ooeh_
zju)y9n@t&;Lt(KRb{dUjj1Dxrm<(r3kgp@Ap^U{uGizZAmcPhycZ-9YS@LdiP%gec
z()$CGmHy%5I23y+7_YGxR)pY^HX?N(uO_*I+tl!gEM+!1)TcJ}sgXYQ>ON(@^JTbC
zagDcV_sz%61X~G07jS%$XcaW11ZB@j(PuzyMQvA`)EQGc`_=F{J9E}JoXh&D#J55w
zL`q@$!Kh1Xw$$l|8}3_m@w0`1?Aj7&9>k{jkz6q}H>!Q2>ym3+l47kp*z7u0@w40n
z(e{9~(dl<uPn2nU(xuOvNW{Rm&bE6mewJikgm;@~IyqTsuUqo0Xj?wG7R`lqNo9JY
z%qJ`N`b>4Mv7oS7z1JpFuTth~&zS{$ZSv#5a*d{0IF~(2=d^qJj%qK%VvuVDkzQ?=
zy}oJ1TgFq@n>jaAFKKV=yT;Y+{?0{nP3?)jzO~!q>VC`TPK8D7jlH?s@t02G5>J6#
z)C^5@<^iAuN&D;iV8~G}wJ-Kvb4G#1J^8V@!fOz>O6&x`Su0+K*!oVM_}OQ1`l@8b
zZqqO$O*+SM8EW-_Co%raZWGcM%`NvPDTW1odD-i=#BCYWVdV4KwaE1yBsWR5c2av{
z-^EjQ$?}$`TEW~|>}3t}xcJ$aGAo<6{4~M^9T9u8)VV3@)=%34=q+DCb5{Fe&x+_e
zBDq1Vuk<?UEiWgUW$lH%eNyOq%6c)&sZ0I;U#Wv{q24a_f2!VklllMOfv<qH1$+Qx
zEkGIP|6^>w0Dl0pAb!6`7;bY4I0c*nP64NYQ@|<U6mSYS1)Ks-fh(avT&=q@``iiJ
zki?!A6tgAu$vbdOnm^<$f9=$&L|SvRyD}jqQMdlmD~=@>EKsrL&!yOxsL|>zvEM1K
z9ceW_DnY$4*WqJaT-$uigwr|>_Vs2^*I7;CxXrq@c{&l8W+e8ppH!Xv4&$2mxx%eT
zx*mU-e`TfpN(++I|NoFWy{z*m_5Zj#`CA-+CU(CP#n*-56mSYS1)Ks-0jGddz$xGq
za0)mDoB~b(r@&<^U`I^p|6|V#CE`!3&0n%hbBP&hq$~Yq3`Og#)c@~iJpDoG_^1BA
z-lpWI)ct<~UjtbK;4ydr-Uq)6O_&8)`)@C7fwk~T_$lK7{u^YR!1v)v_&B^Bj=~UJ
z3xCI$fydxo@Fv&{FN1$1EuVn%@J@I;ybbE0(|OryIgd^Or+`zyDc}@v3OEIv0!{&^
zz!g^@sd5})5>;D`qcy5rPlHHCu_rSs>;UC>oVM=owI6iJZW>N{RIOz^IJ@0)sKe5Z
z$W9wdk8PJQTjQ`(wqn^CrWt#kGUIFaFlESf)^2IbYS_)PGj_Vm+YOh9U3ZkX*>=y7
z?jY}C*{OWoF)lNa?2I>wedM(r%C{_2;fkf5DI~7;YTADDlwF5PW@eV1@h65%VKQ_5
zeEUZMX7*iPPq@>QmP%VGYI?qsjwUI0tztIHG%b_tR(Zn7<~c4nxY%ou6p&G6vujJj
zsIr;T*LzgG#)K+kDwuz@#T?0X8)YJxC&@RLW|WCw`q1b<%49Kp*phCPxntTTmWb4(
N*7%DvwvtI2{|l-C9TWfn

diff --git a/src/line.rs b/src/line.rs
index 45e05e9..557b713 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -14,6 +14,22 @@ pub struct LineParser {
     empty_line: Regex,
 }
 
+#[derive(PartialEq, Debug, Clone)]
+pub enum Error {
+    FailedYearParse(String),
+    FailedMonthParse(String),
+    FailedWeekdayParse(String),
+    InvalidLineType(String),
+    TypeColumnContainedNonHyphen(String),
+    CouldNotParseSaving(String),
+    InvalidDaySpec(String),
+    InvalidTimeSpecAndType(String),
+    NonWallClockInTimeSpec(String),
+    NotParsedAsRuleLine,
+    NotParsedAsZoneLine,
+    NotParsedAsLinkLine,
+}
+
 impl LineParser {
     pub fn new() -> Self {
         LineParser {
@@ -147,22 +163,6 @@ impl Month {
     }
 }
 
-#[derive(PartialEq, Debug, Clone)]
-pub enum Error {
-    FailedYearParse(String),
-    FailedMonthParse(String),
-    FailedWeekdayParse(String),
-    InvalidLineType(String),
-    TypeColumnContainedNonHyphen(String),
-    CouldNotParseSaving(String),
-    InvalidDaySpec(String),
-    InvalidTimeSpecAndType(String),
-    NonWallClockInTimeSpec(String),
-    NotParsedAsRuleLine,
-    NotParsedAsZoneLine,
-    NotParsedAsLinkLine,
-}
-
 impl FromStr for Month {
     type Err = Error;
 

From 7710cf983af0395919c5e5f8bcfdd5a5d655b236 Mon Sep 17 00:00:00 2001
From: Clar Charr <clar@charr.xyz>
Date: Mon, 7 Aug 2017 23:55:55 -0400
Subject: [PATCH 071/113] Update regex crate.

---
 Cargo.toml  |  2 +-
 src/line.rs | 62 ++++++++++++++++++++++++++---------------------------
 2 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index ff7c149..897f671 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,4 +9,4 @@ readme = "README.md"
 license = "MIT"
 
 [dependencies]
-regex = "^0.1"
+regex = "^0.2"
diff --git a/src/line.rs b/src/line.rs
index 557b713..8a11e07 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -533,20 +533,20 @@ impl LineParser {
             Ok(TimeSpecAndType(TimeSpec::Hours(input.parse().unwrap()), TimeType::Wall))
         }
         else if let Some(caps) = self.hm_field.captures(input) {
-            let sign   : i8 = if caps.name("sign").unwrap() == "-" { -1 } else { 1 };
-            let hour   : i8 = caps.name("hour").unwrap().parse().unwrap();
-            let minute : i8 = caps.name("minute").unwrap().parse().unwrap();
-            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
+            let sign   : i8 = if caps.name("sign").unwrap().as_str() == "-" { -1 } else { 1 };
+            let hour   : i8 = caps.name("hour").unwrap().as_str().parse().unwrap();
+            let minute : i8 = caps.name("minute").unwrap().as_str().parse().unwrap();
+            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c.as_str()[0..1]))
                                           .unwrap_or(TimeType::Wall);
 
             Ok(TimeSpecAndType(TimeSpec::HoursMinutes(hour * sign, minute * sign), flag))
         }
         else if let Some(caps) = self.hms_field.captures(input) {
-            let sign   : i8 = if caps.name("sign").unwrap() == "-" { -1 } else { 1 };
-            let hour   : i8 = caps.name("hour").unwrap().parse().unwrap();
-            let minute : i8 = caps.name("minute").unwrap().parse().unwrap();
-            let second : i8 = caps.name("second").unwrap().parse().unwrap();
-            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
+            let sign   : i8 = if caps.name("sign").unwrap().as_str() == "-" { -1 } else { 1 };
+            let hour   : i8 = caps.name("hour").unwrap().as_str().parse().unwrap();
+            let minute : i8 = caps.name("minute").unwrap().as_str().parse().unwrap();
+            let second : i8 = caps.name("second").unwrap().as_str().parse().unwrap();
+            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c.as_str()[0..1]))
                                           .unwrap_or(TimeType::Wall);
 
             Ok(TimeSpecAndType(TimeSpec::HoursMinutesSeconds(hour * sign, minute * sign, second * sign), flag))
@@ -570,10 +570,10 @@ impl LineParser {
             let weekday = input[4..].parse()?;
             Ok(DaySpec::Last(weekday))
         } else if let Some(caps) = self.day_field.captures(input) {
-            let weekday = caps.name("weekday").unwrap().parse().unwrap();
-            let day     = caps.name("day").unwrap().parse().unwrap();
+            let weekday = caps.name("weekday").unwrap().as_str().parse().unwrap();
+            let day     = caps.name("day").unwrap().as_str().parse().unwrap();
 
-            match caps.name("sign").unwrap() {
+            match caps.name("sign").unwrap().as_str() {
                 "<=" => Ok(DaySpec::LastOnOrBefore(weekday, day)),
                 ">=" => Ok(DaySpec::FirstOnOrAfter(weekday, day)),
                  _   => unreachable!("The regex only matches one of those two!"),
@@ -585,12 +585,12 @@ impl LineParser {
 
     fn parse_rule<'a>(&self, input: &'a str) -> Result<Rule<'a>, Error> {
         if let Some(caps) = self.rule_line.captures(input) {
-            let name      = caps.name("name").unwrap();
-            let from_year = caps.name("from").unwrap().parse()?;
+            let name      = caps.name("name").unwrap().as_str();
+            let from_year = caps.name("from").unwrap().as_str().parse()?;
 
             // The end year can be ‘only’ to indicate that this rule only
             // takes place on that year.
-            let to_year = match caps.name("to").unwrap() {
+            let to_year = match caps.name("to").unwrap().as_str() {
                 "only"  => None,
                 to      => Some(to.parse()?),
             };
@@ -599,16 +599,16 @@ impl LineParser {
             // should be “-”, so throw an error if it isn’t. (It only exists
             // for compatibility with old versions that used to contain year
             // types.) Sometimes “‐”, a Unicode hyphen, is used as well.
-            let t = caps.name("type").unwrap();
+            let t = caps.name("type").unwrap().as_str();
             if t != "-" && t != "\u{2010}"  {
                 return Err(Error::TypeColumnContainedNonHyphen(t.to_string()));
             }
 
-            let month        = caps.name("in").unwrap().parse()?;
-            let day          = self.parse_dayspec(caps.name("on").unwrap())?;
-            let time         = self.parse_timespec_and_type(caps.name("at").unwrap())?;
-            let time_to_add  = self.parse_timespec(caps.name("save").unwrap())?;
-            let letters      = match caps.name("letters").unwrap() {
+            let month        = caps.name("in").unwrap().as_str().parse()?;
+            let day          = self.parse_dayspec(caps.name("on").unwrap().as_str())?;
+            let time         = self.parse_timespec_and_type(caps.name("at").unwrap().as_str())?;
+            let time_to_add  = self.parse_timespec(caps.name("save").unwrap().as_str())?;
+            let letters      = match caps.name("letters").unwrap().as_str() {
                 "-"  => None,
                 l    => Some(l),
             };
@@ -642,15 +642,15 @@ impl LineParser {
     }
 
     fn zoneinfo_from_captures<'a>(&self, caps: Captures<'a>) -> Result<ZoneInfo<'a>, Error> {
-        let utc_offset = self.parse_timespec(caps.name("gmtoff").unwrap())?;
-        let saving = self.saving_from_str(caps.name("rulessave").unwrap())?;
-        let format = caps.name("format").unwrap();
+        let utc_offset = self.parse_timespec(caps.name("gmtoff").unwrap().as_str())?;
+        let saving = self.saving_from_str(caps.name("rulessave").unwrap().as_str())?;
+        let format = caps.name("format").unwrap().as_str();
 
         let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
-            (Some(y), Some(m), Some(d), Some(t)) => Some(ChangeTime::UntilTime  (y.parse()?, m.parse()?, self.parse_dayspec(d)?, self.parse_timespec_and_type(t)?)),
-            (Some(y), Some(m), Some(d), _      ) => Some(ChangeTime::UntilDay   (y.parse()?, m.parse()?, self.parse_dayspec(d)?)),
-            (Some(y), Some(m), _      , _      ) => Some(ChangeTime::UntilMonth (y.parse()?, m.parse()?)),
-            (Some(y), _      , _      , _      ) => Some(ChangeTime::UntilYear  (y.parse()?)),
+            (Some(y), Some(m), Some(d), Some(t)) => Some(ChangeTime::UntilTime  (y.as_str().parse()?, m.as_str().parse()?, self.parse_dayspec(d.as_str())?, self.parse_timespec_and_type(t.as_str())?)),
+            (Some(y), Some(m), Some(d), _      ) => Some(ChangeTime::UntilDay   (y.as_str().parse()?, m.as_str().parse()?, self.parse_dayspec(d.as_str())?)),
+            (Some(y), Some(m), _      , _      ) => Some(ChangeTime::UntilMonth (y.as_str().parse()?, m.as_str().parse()?)),
+            (Some(y), _      , _      , _      ) => Some(ChangeTime::UntilYear  (y.as_str().parse()?)),
             (None   , None   , None   , None   ) => None,
             _                                    => unreachable!("Out-of-order capturing groups!"),
         };
@@ -665,7 +665,7 @@ impl LineParser {
 
     fn parse_zone<'a>(&self, input: &'a str) -> Result<Zone<'a>, Error> {
         if let Some(caps) = self.zone_line.captures(input) {
-            let name = caps.name("name").unwrap();
+            let name = caps.name("name").unwrap().as_str();
             let info = self.zoneinfo_from_captures(caps)?;
             Ok(Zone {
                 name: name,
@@ -678,8 +678,8 @@ impl LineParser {
 
     fn parse_link<'a>(&self, input: &'a str) -> Result<Link<'a>, Error> {
         if let Some(caps) = self.link_line.captures(input) {
-            let target  = caps.name("target").unwrap();
-            let name    = caps.name("name").unwrap();
+            let target  = caps.name("target").unwrap().as_str();
+            let name    = caps.name("name").unwrap().as_str();
             Ok(Link { existing: target, new: name })
         }
         else {

From b88c5b14c3cae579eedb2b418ada096ff31217bf Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@knewton.com>
Date: Sun, 8 Oct 2017 16:36:02 -0400
Subject: [PATCH 072/113] Remove warning about unnecessary mut

Still point out that the variable is mutable with a type annotation, though.
---
 src/table.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/table.rs b/src/table.rs
index f4ff10e..92b0f10 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -283,7 +283,7 @@ impl TableBuilder {
             }
         }
 
-        let mut zoneset = match self.table.zonesets.entry(zone_line.name.to_owned()) {
+        let zoneset: &mut _ = match self.table.zonesets.entry(zone_line.name.to_owned()) {
             Entry::Occupied(_)  => return Err(Error::DuplicateZone),
             Entry::Vacant(e)    => e.insert(Vec::new()),
         };
@@ -298,7 +298,7 @@ impl TableBuilder {
     /// Returns an error if the builder wasn’t expecting a continuation line
     /// (meaning, the previous line wasn’t a zone line)
     pub fn add_continuation_line(&mut self, continuation_line: line::ZoneInfo) -> Result<(), Error> {
-        let mut zoneset = match self.current_zoneset_name {
+        let zoneset: &mut _ = match self.current_zoneset_name {
             Some(ref name) => self.table.zonesets.get_mut(name).unwrap(),
             None => return Err(Error::SurpriseContinuationLine),
         };

From b7a251175cb1823cd4f15e24a3f44f9d4e963b13 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@knewton.com>
Date: Sun, 8 Oct 2017 16:36:53 -0400
Subject: [PATCH 073/113] Bump version to 0.1.1

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 897f671..c97c2ef 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "parse-zoneinfo"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Djzin <djzin@users.noreply.github.com>"]
 description = "Parse zoneinfo files from the IANA database"
 keywords = ["date", "time", "timezone", "zone", "calendar"]

From 19611d063c1123a36ea3f96f22ff043e3c40d6ab Mon Sep 17 00:00:00 2001
From: Ariel Dabalsa <arieldabalsa@gmail.com>
Date: Wed, 3 Jan 2018 00:19:21 -0500
Subject: [PATCH 074/113] Optimize leap year checks

Interesting in-depth breakdown:
stackoverflow.com/questions/3220163/how-to-find-leap-year-programatically-in-c/11595914#11595914
---
 src/line.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/line.rs b/src/line.rs
index 8a11e07..2661eba 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -259,7 +259,17 @@ fn weekdays() {
 }
 
 fn is_leap(year: i64) -> bool {
-    year % 4 == 0 && year % 100 != 0 || year % 400 == 0
+    // Leap year rules: years which are factors of 4, except those divisible
+    // by 100, unless they are divisible by 400.
+    //
+    // We test most common cases first: 4th year, 100th year, then 400th year.
+    //
+    // We factor out 4 from 100 since it was already tested, leaving us checking
+    // if it's divisible by 25. Afterwards, we do the same, factoring 25 from
+    // 400, leaving us with 16.
+    //
+    // Factors of 4 and 16 can quickly be found with bitwise AND.
+    year & 3 == 0 && (year % 25 != 0 || year & 15 == 0)
 }
 
 #[cfg(test)]

From 5a04a7aca719607ffc709d1d7dec4e7ebfe6bb0c Mon Sep 17 00:00:00 2001
From: Ariel Dabalsa <arieldabalsa@gmail.com>
Date: Wed, 3 Jan 2018 00:39:19 -0500
Subject: [PATCH 075/113] unwrap_or_else(Fn) instead of unwrap_or(Fn)

These are just creating empty Strings so it's nothing huge. The inner
function in unwrap_or would always be called otherwise, and this is a
little more readable.
---
 src/transitions.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/transitions.rs b/src/transitions.rs
index c318684..6e013c9 100644
--- a/src/transitions.rs
+++ b/src/transitions.rs
@@ -237,7 +237,7 @@ impl FixedTimespanSetBuilder {
             let timespan = FixedTimespan {
                 utc_offset: timespan.offset,
                 dst_offset: *dst_offset,
-                name:       start_zone_id.clone().unwrap_or("".to_owned()),
+                name:       start_zone_id.clone().unwrap_or_else(String::new),
             };
 
             self.rest.push((time, timespan));
@@ -247,7 +247,7 @@ impl FixedTimespanSetBuilder {
             self.first = Some(FixedTimespan {
                 utc_offset: utc_offset,
                 dst_offset: *dst_offset,
-                name:       start_zone_id.clone().unwrap_or("".to_owned()),
+                name:       start_zone_id.clone().unwrap_or_else(String::new),
             });
         }
     }

From eb820351f6f0665e2ab3aa4cbf0964d08b2434ee Mon Sep 17 00:00:00 2001
From: Ariel Dabalsa <arieldabalsa@gmail.com>
Date: Wed, 3 Jan 2018 22:43:57 -0500
Subject: [PATCH 076/113] Remove duplicate rule start-time calculations

absolute_datetime() was being called twice each iteration
---
 src/transitions.rs | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/src/transitions.rs b/src/transitions.rs
index 6e013c9..17e17ad 100644
--- a/src/transitions.rs
+++ b/src/transitions.rs
@@ -273,23 +273,18 @@ impl FixedTimespanSetBuilder {
                     self.until_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - *dst_offset);
                 }
 
-                // Find the minimum rule based on the current UTC and DST offsets.
-                // (this can be replaced with min_by when it stabilises):
-                //.min_by(|r| r.1.absolute_datetime(year, utc_offset, dst_offset));
-                let pos = {
-                    let earliest = activated_rules.iter().enumerate()
-                        .map(|(i, r)| (r.absolute_datetime(year, utc_offset, *dst_offset), i))
-                        .min()
-                        .map(|(_, i)| i);
-
-                    match earliest {
-                        Some(p) => p,
-                        None    => break,
-                    }
+                // Find the minimum rule and its start time based on the current
+                // UTC and DST offsets.
+                let earliest = activated_rules.iter().enumerate()
+                    .map(|(i, r)| (i, r.absolute_datetime(year, utc_offset, *dst_offset)))
+                    .min_by_key(|&(_, time)| time);
+
+                let (pos, earliest_at) = match earliest {
+                    Some((pos, time)) => (pos, time),
+                    None => break,
                 };
 
                 let earliest_rule = activated_rules.remove(pos);
-                let earliest_at = earliest_rule.absolute_datetime(year, utc_offset, *dst_offset);
 
                 if use_until && earliest_at >= self.until_time.unwrap() {
                     break;

From 078cf6afee7fe20e33e01bed4df684c2bfd068a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonathan=20Schleu=C3=9Fer?= <ParadoxSpiral@riseup.net>
Date: Sun, 20 May 2018 14:43:19 +0200
Subject: [PATCH 077/113] Bump regex version

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index c97c2ef..d9c1536 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,4 +9,4 @@ readme = "README.md"
 license = "MIT"
 
 [dependencies]
-regex = "^0.2"
+regex = "1"

From dc6aa7d15ef7633f7cc234b9ea50808999ce92dd Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@knewton.com>
Date: Thu, 28 Jun 2018 21:05:21 -0400
Subject: [PATCH 078/113] Don't warn when importing AsciiExt

When we update to depend on rust 1.26 we can remove this silencing.
---
 src/line.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/line.rs b/src/line.rs
index 2661eba..50ed148 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -1,4 +1,6 @@
 use std::str::FromStr;
+// we still support rust that doesn't have the inherent methods
+#[allow(deprecated, unused_imports)]
 use std::ascii::AsciiExt;
 
 use regex::{Regex, Captures};

From 66755736326b10d4c99853ab6667413c58342179 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@knewton.com>
Date: Thu, 28 Jun 2018 21:06:25 -0400
Subject: [PATCH 079/113] Bump version to 0.2.0

* New regex version
---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index d9c1536..4e92973 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "parse-zoneinfo"
-version = "0.1.1"
+version = "0.2.0"
 authors = ["Djzin <djzin@users.noreply.github.com>"]
 description = "Parse zoneinfo files from the IANA database"
 keywords = ["date", "time", "timezone", "zone", "calendar"]

From e5297731e0275bb7dd58b2bd03ac735dbffdfcea Mon Sep 17 00:00:00 2001
From: Ran Benita <ran@unusedvar.com>
Date: Thu, 24 Oct 2019 22:38:44 +0300
Subject: [PATCH 080/113] Add a benchmark

---
 examples/asia         | 3651 +++++++++++++++++++++++++++++++++++++++++
 examples/benchmark.rs |   34 +
 2 files changed, 3685 insertions(+)
 create mode 100644 examples/asia
 create mode 100644 examples/benchmark.rs

diff --git a/examples/asia b/examples/asia
new file mode 100644
index 0000000..cca004f
--- /dev/null
+++ b/examples/asia
@@ -0,0 +1,3651 @@
+# tzdb data for Asia and environs
+
+# This file is in the public domain, so clarified as of
+# 2009-05-17 by Arthur David Olson.
+
+# This file is by no means authoritative; if you think you know better,
+# go ahead and edit the file (and please send any changes to
+# tz@iana.org for general use in the future).  For more, please see
+# the file CONTRIBUTING in the tz distribution.
+
+# From Paul Eggert (2019-07-11):
+#
+# Unless otherwise specified, the source for data through 1990 is:
+# Thomas G. Shanks and Rique Pottenger, The International Atlas (6th edition),
+# San Diego: ACS Publications, Inc. (2003).
+# Unfortunately this book contains many errors and cites no sources.
+#
+# Many years ago Gwillim Law wrote that a good source
+# for time zone data was the International Air Transport
+# Association's Standard Schedules Information Manual (IATA SSIM),
+# published semiannually.  Law sent in several helpful summaries
+# of the IATA's data after 1990.  Except where otherwise noted,
+# IATA SSIM is the source for entries after 1990.
+#
+# Another source occasionally used is Edward W. Whitman, World Time Differences,
+# Whitman Publishing Co, 2 Niagara Av, Ealing, London (undated), which
+# I found in the UCLA library.
+#
+# For data circa 1899, a common source is:
+# Milne J. Civil time. Geogr J. 1899 Feb;13(2):173-94.
+# https://www.jstor.org/stable/1774359
+#
+# For Russian data circa 1919, a source is:
+# Byalokoz EL. New Counting of Time in Russia since July 1, 1919.
+# (See the 'europe' file for a fuller citation.)
+#
+# A reliable and entertaining source about time zones is
+# Derek Howse, Greenwich time and longitude, Philip Wilson Publishers (1997).
+#
+# The following alphabetic abbreviations appear in these tables
+# (corrections are welcome):
+#	     std  dst
+#	     LMT	Local Mean Time
+#	2:00 EET  EEST	Eastern European Time
+#	2:00 IST  IDT	Israel
+#	5:30 IST	India
+#	7:00 WIB	west Indonesia (Waktu Indonesia Barat)
+#	8:00 WITA	central Indonesia (Waktu Indonesia Tengah)
+#	8:00 CST	China
+#	8:00 HKT  HKST	Hong Kong (HKWT* for Winter Time in late 1941)
+#	8:00 PST  PDT*	Philippines
+#	8:30 KST  KDT	Korea when at +0830
+#	9:00 WIT	east Indonesia (Waktu Indonesia Timur)
+#	9:00 JST  JDT	Japan
+#	9:00 KST  KDT	Korea when at +09
+# *I invented the abbreviations HKWT and PDT; see below.
+# Otherwise, these tables typically use numeric abbreviations like +03
+# and +0330 for integer hour and minute UT offsets.  Although earlier
+# editions invented alphabetic time zone abbreviations for every
+# offset, this did not reflect common practice.
+#
+# See the 'europe' file for Russia and Turkey in Asia.
+
+# From Guy Harris:
+# Incorporates data for Singapore from Robert Elz' asia 1.1, as well as
+# additional information from Tom Yap, Sun Microsystems Intercontinental
+# Technical Support (including a page from the Official Airline Guide -
+# Worldwide Edition).
+
+###############################################################################
+
+# These rules are stolen from the 'europe' file.
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	EUAsia	1981	max	-	Mar	lastSun	 1:00u	1:00	S
+Rule	EUAsia	1979	1995	-	Sep	lastSun	 1:00u	0	-
+Rule	EUAsia	1996	max	-	Oct	lastSun	 1:00u	0	-
+Rule E-EurAsia	1981	max	-	Mar	lastSun	 0:00	1:00	-
+Rule E-EurAsia	1979	1995	-	Sep	lastSun	 0:00	0	-
+Rule E-EurAsia	1996	max	-	Oct	lastSun	 0:00	0	-
+Rule RussiaAsia	1981	1984	-	Apr	1	 0:00	1:00	-
+Rule RussiaAsia	1981	1983	-	Oct	1	 0:00	0	-
+Rule RussiaAsia	1984	1995	-	Sep	lastSun	 2:00s	0	-
+Rule RussiaAsia	1985	2010	-	Mar	lastSun	 2:00s	1:00	-
+Rule RussiaAsia	1996	2010	-	Oct	lastSun	 2:00s	0	-
+
+# Afghanistan
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Kabul	4:36:48 -	LMT	1890
+			4:00	-	+04	1945
+			4:30	-	+0430
+
+# Armenia
+# From Paul Eggert (2006-03-22):
+# Shanks & Pottenger have Yerevan switching to 3:00 (with Russian DST)
+# in spring 1991, then to 4:00 with no DST in fall 1995, then
+# readopting Russian DST in 1997.  Go with Shanks & Pottenger, even
+# when they disagree with others.  Edgar Der-Danieliantz
+# reported (1996-05-04) that Yerevan probably wouldn't use DST
+# in 1996, though it did use DST in 1995.  IATA SSIM (1991/1998) reports that
+# Armenia switched from 3:00 to 4:00 in 1998 and observed DST after 1991,
+# but started switching at 3:00s in 1998.
+
+# From Arthur David Olson (2011-06-15):
+# While Russia abandoned DST in 2011, Armenia may choose to
+# follow Russia's "old" rules.
+
+# From Alexander Krivenyshev (2012-02-10):
+# According to News Armenia, on Feb 9, 2012,
+# http://newsarmenia.ru/society/20120209/42609695.html
+#
+# The Armenia National Assembly adopted final reading of Amendments to the
+# Law "On procedure of calculation time on the territory of the Republic of
+# Armenia" according to which Armenia [is] abolishing Daylight Saving Time.
+# or
+# (brief)
+# http://www.worldtimezone.com/dst_news/dst_news_armenia03.html
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule Armenia	2011	only	-	Mar	lastSun	 2:00s	1:00	-
+Rule Armenia	2011	only	-	Oct	lastSun	 2:00s	0	-
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Yerevan	2:58:00 -	LMT	1924 May  2
+			3:00	-	+03	1957 Mar
+			4:00 RussiaAsia +04/+05	1991 Mar 31  2:00s
+			3:00 RussiaAsia	+03/+04	1995 Sep 24  2:00s
+			4:00	-	+04	1997
+			4:00 RussiaAsia	+04/+05	2011
+			4:00	Armenia	+04/+05
+
+# Azerbaijan
+
+# From Rustam Aliyev of the Azerbaijan Internet Forum (2005-10-23):
+# According to the resolution of Cabinet of Ministers, 1997
+# From Paul Eggert (2015-09-17): It was Resolution No. 21 (1997-03-17).
+# http://code.az/files/daylight_res.pdf
+
+# From Steffen Thorsen (2016-03-17):
+# ... the Azerbaijani Cabinet of Ministers has cancelled switching to
+# daylight saving time....
+# https://www.azernews.az/azerbaijan/94137.html
+# http://vestnikkavkaza.net/news/Azerbaijani-Cabinet-of-Ministers-cancels-daylight-saving-time.html
+# http://en.apa.az/xeber_azerbaijan_abolishes_daylight_savings_ti_240862.html
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Azer	1997	2015	-	Mar	lastSun	 4:00	1:00	-
+Rule	Azer	1997	2015	-	Oct	lastSun	 5:00	0	-
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Baku	3:19:24 -	LMT	1924 May  2
+			3:00	-	+03	1957 Mar
+			4:00 RussiaAsia +04/+05	1991 Mar 31  2:00s
+			3:00 RussiaAsia	+03/+04	1992 Sep lastSun  2:00s
+			4:00	-	+04	1996
+			4:00	EUAsia	+04/+05	1997
+			4:00	Azer	+04/+05
+
+# Bahrain
+# See Asia/Qatar.
+
+# Bangladesh
+# From Alexander Krivenyshev (2009-05-13):
+# According to newspaper Asian Tribune (May 6, 2009) Bangladesh may introduce
+# Daylight Saving Time from June 16 to Sept 30
+#
+# Bangladesh to introduce daylight saving time likely from June 16
+# http://www.asiantribune.com/?q=node/17288
+# http://www.worldtimezone.com/dst_news/dst_news_bangladesh02.html
+#
+# "... Bangladesh government has decided to switch daylight saving time from
+# June
+# 16 till September 30 in a bid to ensure maximum use of daylight to cope with
+# crippling power crisis. "
+#
+# The switch will remain in effect from June 16 to Sept 30 (2009) but if
+# implemented the next year, it will come in force from April 1, 2010
+
+# From Steffen Thorsen (2009-06-02):
+# They have finally decided now, but changed the start date to midnight between
+# the 19th and 20th, and they have not set the end date yet.
+#
+# Some sources:
+# https://in.reuters.com/article/southAsiaNews/idINIndia-40017620090601
+# http://bdnews24.com/details.php?id=85889&cid=2
+#
+# Our wrap-up:
+# https://www.timeanddate.com/news/time/bangladesh-daylight-saving-2009.html
+
+# From A. N. M. Kamrus Saadat (2009-06-15):
+# Finally we've got the official mail regarding DST start time where DST start
+# time is mentioned as Jun 19 2009, 23:00 from BTRC (Bangladesh
+# Telecommunication Regulatory Commission).
+#
+# No DST end date has been announced yet.
+
+# From Alexander Krivenyshev (2009-09-25):
+# Bangladesh won't go back to Standard Time from October 1, 2009,
+# instead it will continue DST measure till the cabinet makes a fresh decision.
+#
+# Following report by same newspaper-"The Daily Star Friday":
+# "DST change awaits cabinet decision-Clock won't go back by 1-hr from Oct 1"
+# http://www.thedailystar.net/newDesign/news-details.php?nid=107021
+# http://www.worldtimezone.com/dst_news/dst_news_bangladesh04.html
+
+# From Steffen Thorsen (2009-10-13):
+# IANS (Indo-Asian News Service) now reports:
+# Bangladesh has decided that the clock advanced by an hour to make
+# maximum use of daylight hours as an energy saving measure would
+# "continue for an indefinite period."
+#
+# One of many places where it is published:
+# http://www.thaindian.com/newsportal/business/bangladesh-to-continue-indefinitely-with-advanced-time_100259987.html
+
+# From Alexander Krivenyshev (2009-12-24):
+# According to Bangladesh newspaper "The Daily Star,"
+# Bangladesh will change its clock back to Standard Time on Dec 31, 2009.
+#
+# Clock goes back 1-hr on Dec 31 night.
+# http://www.thedailystar.net/newDesign/news-details.php?nid=119228
+# http://www.worldtimezone.com/dst_news/dst_news_bangladesh05.html
+#
+# "...The government yesterday decided to put the clock back by one hour
+# on December 31 midnight and the new time will continue until March 31,
+# 2010 midnight. The decision came at a cabinet meeting at the Prime
+# Minister's Office last night..."
+
+# From Alexander Krivenyshev (2010-03-22):
+# According to Bangladesh newspaper "The Daily Star,"
+# Cabinet cancels Daylight Saving Time
+# http://www.thedailystar.net/newDesign/latest_news.php?nid=22817
+# http://www.worldtimezone.com/dst_news/dst_news_bangladesh06.html
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Dhaka	2009	only	-	Jun	19	23:00	1:00	-
+Rule	Dhaka	2009	only	-	Dec	31	24:00	0	-
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Dhaka	6:01:40 -	LMT	1890
+			5:53:20	-	HMT	1941 Oct    # Howrah Mean Time?
+			6:30	-	+0630	1942 May 15
+			5:30	-	+0530	1942 Sep
+			6:30	-	+0630	1951 Sep 30
+			6:00	-	+06	2009
+			6:00	Dhaka	+06/+07
+
+# Bhutan
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Thimphu	5:58:36 -	LMT	1947 Aug 15 # or Thimbu
+			5:30	-	+0530	1987 Oct
+			6:00	-	+06
+
+# British Indian Ocean Territory
+# Whitman and the 1995 CIA time zone map say 5:00, but the
+# 1997 and later maps say 6:00.  Assume the switch occurred in 1996.
+# We have no information as to when standard time was introduced;
+# assume it occurred in 1907, the same year as Mauritius (which
+# then contained the Chagos Archipelago).
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Indian/Chagos	4:49:40	-	LMT	1907
+			5:00	-	+05	1996
+			6:00	-	+06
+
+# Brunei
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Brunei	7:39:40 -	LMT	1926 Mar # Bandar Seri Begawan
+			7:30	-	+0730	1933
+			8:00	-	+08
+
+# Burma / Myanmar
+
+# Milne says 6:24:40 was the meridian of the time ball observatory at Rangoon.
+
+# From Paul Eggert (2017-04-20):
+# Page 27 of Reed & Low (cited for Asia/Kolkata) says "Rangoon local time is
+# used upon the railways and telegraphs of Burma, and is 6h. 24m. 47s. ahead
+# of Greenwich."  This refers to the period before Burma's transition to +0630,
+# a transition for which Shanks is the only source.
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Yangon	6:24:47 -	LMT	1880        # or Rangoon
+			6:24:47	-	RMT	1920        # Rangoon local time
+			6:30	-	+0630	1942 May
+			9:00	-	+09	1945 May  3
+			6:30	-	+0630
+
+# Cambodia
+# See Asia/Bangkok.
+
+
+# China
+
+# From Paul Eggert (2018-10-02):
+# The following comes from Table 1 of:
+# Li Yu. Research on the daylight saving movement in 1940s Shanghai.
+# Nanjing Journal of Social Sciences. 2014;(2):144-50.
+# http://oversea.cnki.net/kns55/detail.aspx?dbname=CJFD2014&filename=NJSH201402020
+# The table lists dates only; I am guessing 00:00 and 24:00 transition times.
+# Also, the table lists the planned end of DST in 1949, but the corresponding
+# zone line cuts this off on May 28, when the Communists took power.
+#
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Shang	1940	only	-	Jun	 1	 0:00	1:00	D
+Rule	Shang	1940	only	-	Oct	12	24:00	0	S
+Rule	Shang	1941	only	-	Mar	15	 0:00	1:00	D
+Rule	Shang	1941	only	-	Nov	 1	24:00	0	S
+Rule	Shang	1942	only	-	Jan	31	 0:00	1:00	D
+Rule	Shang	1945	only	-	Sep	 1	24:00	0	S
+Rule	Shang	1946	only	-	May	15	 0:00	1:00	D
+Rule	Shang	1946	only	-	Sep	30	24:00	0	S
+Rule	Shang	1947	only	-	Apr	15	 0:00	1:00	D
+Rule	Shang	1947	only	-	Oct	31	24:00	0	S
+Rule	Shang	1948	1949	-	May	 1	 0:00	1:00	D
+Rule	Shang	1948	1949	-	Sep	30	24:00	0	S #plan
+
+# From Guy Harris:
+# People's Republic of China.  Yes, they really have only one time zone.
+
+# From Bob Devine (1988-01-28):
+# No they don't.  See TIME mag, 1986-02-17 p.52.  Even though
+# China is across 4 physical time zones, before Feb 1, 1986 only the
+# Peking (Beijing) time zone was recognized.  Since that date, China
+# has two of 'em - Peking's and Ürümqi (named after the capital of
+# the Xinjiang Uyghur Autonomous Region).  I don't know about DST for it.
+#
+# . . .I just deleted the DST table and this editor makes it too
+# painful to suck in another copy.  So, here is what I have for
+# DST start/end dates for Peking's time zone (info from AP):
+#
+#     1986 May 4 - Sept 14
+#     1987 mid-April - ??
+
+# From U. S. Naval Observatory (1989-01-19):
+# CHINA               8 H  AHEAD OF UTC  ALL OF CHINA, INCL TAIWAN
+# CHINA               9 H  AHEAD OF UTC  APR 17 - SEP 10
+
+# From Paul Eggert (2008-02-11):
+# Jim Mann, "A clumsy embrace for another western custom: China on daylight
+# time - sort of", Los Angeles Times, 1986-05-05 ... [says] that China began
+# observing daylight saving time in 1986.
+
+# From P Chan (2018-05-07):
+# The start and end time of DST in China [from 1986 on] should be 2:00
+# (i.e. 2:00 to 3:00 at the start and 2:00 to 1:00 at the end)....
+# Government notices about summer time:
+#
+# 1986-04-12 http://www.zj.gov.cn/attach/zfgb/198608.pdf p.21-22
+# (To establish summer time from 1986. On 4 May, set the clocks ahead one hour
+# at 2 am. On 14 September, set the clocks backward one hour at 2 am.)
+#
+# 1987-02-15 http://www.gov.cn/gongbao/shuju/1987/gwyb198703.pdf p.114
+# (Summer time in 1987 to start from 12 April until 13 September)
+#
+# 1987-09-09 http://www.gov.cn/gongbao/shuju/1987/gwyb198721.pdf p.709
+# (From 1988, summer time to start from 2 am of the first Sunday of mid-April
+# until 2 am of the first Sunday of mid-September)
+#
+# 1992-03-03 http://www.gov.cn/gongbao/shuju/1992/gwyb199205.pdf p.152
+# (To suspend summer time from 1992)
+#
+# The first page of People's Daily on 12 April 1988 stating that summer time
+# to begin on 17 April.
+# http://data.people.com.cn/pic/101p/1988/04/1988041201.jpg
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	PRC	1986	only	-	May	 4	 2:00	1:00	D
+Rule	PRC	1986	1991	-	Sep	Sun>=11	 2:00	0	S
+Rule	PRC	1987	1991	-	Apr	Sun>=11	 2:00	1:00	D
+
+# From Anthony Fok (2001-12-20):
+# BTW, I did some research on-line and found some info regarding these five
+# historic timezones from some Taiwan websites.  And yes, there are official
+# Chinese names for these locales (before 1949).
+#
+# From Jesper Nørgaard Welen (2006-07-14):
+# I have investigated the timezones around 1970 on the
+# https://www.astro.com/atlas site [with provinces and county
+# boundaries summarized below]....  A few other exceptions were two
+# counties on the Sichuan side of the Xizang-Sichuan border,
+# counties Dege and Baiyu which lies on the Sichuan side and are
+# therefore supposed to be GMT+7, Xizang region being GMT+6, but Dege
+# county is GMT+8 according to astro.com while Baiyu county is GMT+6
+# (could be true), for the moment I am assuming that those two
+# counties are mistakes in the astro.com data.
+
+# From Paul Eggert (2017-01-05):
+# Alois Treindl kindly sent me translations of the following two sources:
+#
+# (1)
+# Guo Qing-sheng (National Time-Service Center, CAS, Xi'an 710600, China)
+# Beijing Time at the Beginning of the PRC
+# China Historical Materials of Science and Technology
+# (Zhongguo ke ji shi liao, 中国科技史料). 2003;24(1):5-9.
+# http://oversea.cnki.net/kcms/detail/detail.aspx?filename=ZGKS200301000&dbname=CJFD2003
+# It gives evidence that at the beginning of the PRC, Beijing time was
+# officially apparent solar time!  However, Guo also says that the
+# evidence is dubious, as the relevant institute of astronomy had not
+# been taken over by the PRC yet.  It's plausible that apparent solar
+# time was announced but never implemented, and that people continued
+# to use UT+8.  As the Shanghai radio station (and I presume the
+# observatory) was still under control of French missionaries, it
+# could well have ignored any such mandate.
+#
+# (2)
+# Guo Qing-sheng (Shaanxi Astronomical Observatory, CAS, Xi'an 710600, China)
+# A Study on the Standard Time Changes for the Past 100 Years in China
+# [undated and unknown publication location]
+# It says several things:
+#   * The Qing dynasty used local apparent solar time throughout China.
+#   * The Republic of China instituted Beijing mean solar time effective
+#     the official calendar book of 1914.
+#   * The French Concession in Shanghai set up signal stations in
+#     French docks in the 1890s, controlled by Xujiahui (Zikawei)
+#     Observatory and set to local mean time.
+#   * "From the end of the 19th century" it changed to UT+8.
+#   * Chinese Customs (by then reduced to a tool of foreign powers)
+#     eventually standardized on this time for all ports, and it
+#     became used by railways as well.
+#   * In 1918 the Central Observatory proposed dividing China into
+#     five time zones (see below for details).  This caught on
+#     at first only in coastal areas observing UT+8.
+#   * During WWII all of China was in theory was at UT+7.  In practice
+#     this was ignored in the west, and I presume was ignored in
+#     Japanese-occupied territory.
+#   * Japanese-occupied Manchuria was at UT+9, i.e., Japan time.
+#   * The five-zone plan was resurrected after WWII and officially put into
+#     place (with some modifications) in March 1948.  It's not clear
+#     how well it was observed in areas under Nationalist control.
+#   * The People's Liberation Army used UT+8 during the civil war.
+#
+# An AP article "Shanghai Internat'l Area Little Changed" in the
+# Lewiston (ME) Daily Sun (1939-05-29), p 17, said "Even the time is
+# different - the occupied districts going by Tokyo time, an hour
+# ahead of that prevailing in the rest of Shanghai."  Guess that the
+# Xujiahui Observatory was under French control and stuck with UT +08.
+#
+# In earlier versions of this file, China had many separate Zone entries, but
+# this was based on what were apparently incorrect data in Shanks & Pottenger.
+# This has now been simplified to the two entries Asia/Shanghai and
+# Asia/Urumqi, with the others being links for backward compatibility.
+# Proposed in 1918 and theoretically in effect until 1949 (although in practice
+# mainly observed in coastal areas), the five zones were:
+#
+# Changbai Time ("Long-white Time", Long-white = Heilongjiang area) UT +08:30
+# Now part of Asia/Shanghai; its pre-1970 times are not recorded here.
+# Heilongjiang (except Mohe county), Jilin
+#
+# Zhongyuan Time ("Central plain Time") UT +08
+# Now part of Asia/Shanghai.
+# most of China
+# Milne gives 8:05:43.2 for Xujiahui Observatory time; round to nearest.
+# Guo says Shanghai switched to UT +08 "from the end of the 19th century".
+#
+# Long-shu Time (probably as Long and Shu were two names of the area) UT +07
+# Now part of Asia/Shanghai; its pre-1970 times are not recorded here.
+# Guangxi, Guizhou, Hainan, Ningxia, Sichuan, Shaanxi, and Yunnan;
+# most of Gansu; west Inner Mongolia; east Qinghai; and the Guangdong
+# counties Deqing, Enping, Kaiping, Luoding, Taishan, Xinxing,
+# Yangchun, Yangjiang, Yu'nan, and Yunfu.
+#
+# Xin-zang Time ("Xinjiang-Tibet Time") UT +06
+# This region is now part of either Asia/Urumqi or Asia/Shanghai with
+# current boundaries uncertain; times before 1970 for areas that
+# disagree with Ürümqi or Shanghai are not recorded here.
+# The Gansu counties Aksay, Anxi, Dunhuang, Subei; west Qinghai;
+# the Guangdong counties  Xuwen, Haikang, Suixi, Lianjiang,
+# Zhanjiang, Wuchuan, Huazhou, Gaozhou, Maoming, Dianbai, and Xinyi;
+# east Tibet, including Lhasa, Chamdo, Shigaise, Jimsar, Shawan and Hutubi;
+# east Xinjiang, including Ürümqi, Turpan, Karamay, Korla, Minfeng, Jinghe,
+# Wusu, Qiemo, Xinyan, Wulanwusu, Jinghe, Yumin, Tacheng, Tuoli, Emin,
+# Shihezi, Changji, Yanqi, Heshuo, Tuokexun, Tulufan, Shanshan, Hami,
+# Fukang, Kuitun, Kumukuli, Miquan, Qitai, and Turfan.
+#
+# Kunlun Time UT +05:30
+# This region is now in the same status as Xin-zang Time (see above).
+# West Tibet, including Pulan, Aheqi, Shufu, Shule;
+# West Xinjiang, including Aksu, Atushi, Yining, Hetian, Cele, Luopu, Nileke,
+# Zhaosu, Tekesi, Gongliu, Chabuchaer, Huocheng, Bole, Pishan, Suiding,
+# and Yarkand.
+
+# From Luther Ma (2009-10-17):
+# Almost all (>99.9%) ethnic Chinese (properly ethnic Han) living in
+# Xinjiang use Chinese Standard Time. Some are aware of Xinjiang time,
+# but have no need of it. All planes, trains, and schools function on
+# what is called "Beijing time." When Han make an appointment in Chinese
+# they implicitly use Beijing time.
+#
+# On the other hand, ethnic Uyghurs, who make up about half the
+# population of Xinjiang, typically use "Xinjiang time" which is two
+# hours behind Beijing time, or UT +06. The government of the Xinjiang
+# Uyghur Autonomous Region, (XAUR, or just Xinjiang for short) as well as
+# local governments such as the Ürümqi city government use both times in
+# publications, referring to what is popularly called Xinjiang time as
+# "Ürümqi time." When Uyghurs make an appointment in the Uyghur language
+# they almost invariably use Xinjiang time.
+#
+# (Their ethnic Han compatriots would typically have no clue of its
+# widespread use, however, because so extremely few of them are fluent in
+# Uyghur, comparable to the number of Anglo-Americans fluent in Navajo.)
+#
+# (...As with the rest of China there was a brief interval ending in 1990
+# or 1991 when summer time was in use.  The confusion was severe, with
+# the province not having dual times but four times in use at the same
+# time. Some areas remained on standard Xinjiang time or Beijing time and
+# others moving their clocks ahead.)
+
+# From Luther Ma (2009-11-19):
+# With the risk of being redundant to previous answers these are the most common
+# English "transliterations" (w/o using non-English symbols):
+#
+# 1. Wulumuqi...
+# 2. Kashi...
+# 3. Urumqi...
+# 4. Kashgar...
+# ...
+# 5. It seems that Uyghurs in Ürümqi has been using Xinjiang since at least the
+# 1960's. I know of one Han, now over 50, who grew up in the surrounding
+# countryside and used Xinjiang time as a child.
+#
+# 6. Likewise for Kashgar and the rest of south Xinjiang I don't know of any
+# start date for Xinjiang time.
+#
+# Without having access to local historical records, nor the ability to legally
+# publish them, I would go with October 1, 1949, when Xinjiang became the Uyghur
+# Autonomous Region under the PRC. (Before that Uyghurs, of course, would also
+# not be using Beijing time, but some local time.)
+
+# From David Cochrane (2014-03-26):
+# Just a confirmation that Ürümqi time was implemented in Ürümqi on 1 Feb 1986:
+# https://content.time.com/time/magazine/article/0,9171,960684,00.html
+
+# From Luther Ma (2014-04-22):
+# I have interviewed numerous people of various nationalities and from
+# different localities in Xinjiang and can confirm the information in Guo's
+# report regarding Xinjiang, as well as the Time article reference by David
+# Cochrane.  Whether officially recognized or not (and both are officially
+# recognized), two separate times have been in use in Xinjiang since at least
+# the Cultural Revolution: Xinjiang Time (XJT), aka Ürümqi Time or local time;
+# and Beijing Time.  There is no confusion in Xinjiang as to which name refers
+# to which time. Both are widely used in the province, although in some
+# population groups might be use one to the exclusion of the other.  The only
+# problem is that computers and smart phones list Ürümqi (or Kashgar) as
+# having the same time as Beijing.
+
+# From Paul Eggert (2014-06-30):
+# In the early days of the PRC, Tibet was given its own time zone (UT +06)
+# but this was withdrawn in 1959 and never reinstated; see Tubten Khétsun,
+# Memories of life in Lhasa under Chinese Rule, Columbia U Press, ISBN
+# 978-0231142861 (2008), translator's introduction by Matthew Akester, p x.
+# As this is before our 1970 cutoff, Tibet doesn't need a separate zone.
+#
+# Xinjiang Time is well-documented as being officially recognized.  E.g., see
+# "The Working-Calendar for The Xinjiang Uygur Autonomous Region Government"
+# <http://www.sinkiang.gov.cn/service/ourworking/> (2014-04-22).
+# Unfortunately, we have no good records of time in Xinjiang before 1986.
+# During the 20th century parts of Xinjiang were ruled by the Qing dynasty,
+# the Republic of China, various warlords, the First and Second East Turkestan
+# Republics, the Soviet Union, the Kuomintang, and the People's Republic of
+# China, and tracking down all these organizations' timekeeping rules would be
+# quite a trick.  Approximate this lost history by a transition from LMT to
+# UT +06 at the start of 1928, the year of accession of the warlord Jin Shuren,
+# which happens to be the date given by Shanks & Pottenger (no doubt as a
+# guess) as the transition from LMT.  Ignore the usage of +08 before
+# 1986-02-01 under the theory that the transition date to +08 is unknown and
+# that the sort of users who prefer Asia/Urumqi now typically ignored the
+# +08 mandate back then.
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+# Beijing time, used throughout China; represented by Shanghai.
+Zone	Asia/Shanghai	8:05:43	-	LMT	1901
+			8:00	Shang	C%sT	1949 May 28
+			8:00	PRC	C%sT
+# Xinjiang time, used by many in western China; represented by Ürümqi / Ürümchi
+# / Wulumuqi.  (Please use Asia/Shanghai if you prefer Beijing time.)
+Zone	Asia/Urumqi	5:50:20	-	LMT	1928
+			6:00	-	+06
+
+
+# Hong Kong (Xianggang)
+
+# Milne gives 7:36:41.7; round this.
+
+# From Lee Yiu Chung (2009-10-24):
+# I found there are some mistakes for the...DST rule for Hong
+# Kong. [According] to the DST record from Hong Kong Observatory (actually,
+# it is not [an] observatory, but the official meteorological agency of HK,
+# and also serves as the official timing agency), there are some missing
+# and incorrect rules. Although the exact switch over time is missing, I
+# think 3:30 is correct. The official DST record for Hong Kong can be
+# obtained from
+# http://www.hko.gov.hk/gts/time/Summertime.htm
+
+# From Phake Nick (2018-10-27):
+# According to Singaporean newspaper
+# http://eresources.nlb.gov.sg/newspapers/Digitised/Article/singfreepresswk19041102-1.2.37
+# the day that Hong Kong start using GMT+8 should be Oct 30, 1904.
+#
+# From Paul Eggert (2018-11-17):
+# Hong Kong had a time ball near the Marine Police Station, Tsim Sha Tsui.
+# "The ball was raised manually each day and dropped at exactly 1pm
+# (except on Sundays and Government holidays)."
+# Dyson AD. From Time Ball to Atomic Clock. Hong Kong Government. 1983.
+# <https://www.hko.gov.hk/publica/gen_pub/timeball_atomic_clock.pdf>
+# "From 1904 October 30 the time-ball at Hong Kong has been dropped by order
+# of the Governor of the Colony at 17h 0m 0s G.M.T., which is 23m 18s.14 in
+# advance of 1h 0m 0s of Hong Kong mean time."
+# Hollis HP. Universal Time, Longitudes, and Geodesy. Mon Not R Astron Soc.
+# 1905-02-10;65(4):405-6. https://doi.org/10.1093/mnras/65.4.382
+#
+# From Joseph Myers (2018-11-18):
+# An astronomer before 1925 referring to GMT would have been using the old
+# astronomical convention where the day started at noon, not midnight.
+#
+# From Steve Allen (2018-11-17):
+# Meteorological Observations made at the Hongkong Observatory in the year 1904
+# page 4 <https://books.google.com/books?id=kgw5AQAAMAAJ&pg=RA4-PA4>
+# ... the log of drop times in Table II shows that on Sunday 1904-10-30 the
+# ball was dropped.  So that looks like a special case drop for the sake
+# of broadcasting the new local time.
+#
+# From Phake Nick (2018-11-18):
+# According to The Hong Kong Weekly Press, 1904-10-29, p.324, the
+# governor of Hong Kong at the time stated that "We are further desired to
+# make it known that the change will be effected by firing the gun and by the
+# dropping of the Ball at 23min. 18sec. before one."
+# From Paul Eggert (2018-11-18):
+# See <https://mmis.hkpl.gov.hk> for this; unfortunately Flash is required.
+
+# From Phake Nick (2018-10-26):
+# I went to check microfilm records stored at Hong Kong Public Library....
+# on September 30 1941, according to Ta Kung Pao (Hong Kong edition), it was
+# stated that fallback would occur on the next day (the 1st)'s "03:00 am (Hong
+# Kong Time 04:00 am)" and the clock will fall back for a half hour. (03:00
+# probably refer to the time commonly used in mainland China at the time given
+# the paper's background) ... the sunrise/sunset time given by South China
+# Morning Post for October 1st was indeed moved by half an hour compares to
+# before.  After that, in December, the battle to capture Hong Kong started and
+# the library doesn't seems to have any record stored about press during that
+# period of time.  Some media resumed publication soon after that within the
+# same month, but there were not much information about time there.  Later they
+# started including a radio program guide when they restored radio service,
+# explicitly mentioning it use Tokyo standard time, and later added a note
+# saying it's half an hour ahead of the old Hong Kong standard time, and it
+# also seems to indicate that Hong Kong was not using GMT+8 when it was
+# captured by Japan.
+#
+# Image of related sections on newspaper:
+# * 1941-09-30, Ta Kung Pao (Hong Kong), "Winter Time start tomorrow".
+#   https://i.imgur.com/6waY51Z.jpg (Chinese)
+# * 1941-09-29, South China Morning Post, Information on sunrise/sunset
+#   time and other things for September 30 and October 1.
+#   https://i.imgur.com/kCiUR78.jpg
+# * 1942-02-05. The Hong Kong News, Radio Program Guide.
+#   https://i.imgur.com/eVvDMzS.jpg
+# * 1941-06-14. Hong Kong Daily Press, Daylight Saving from 3am Tomorrow.
+#   https://i.imgur.com/05KkvtC.png
+# * 1941-09-30, Hong Kong Daily Press, Winter Time Warning.
+#   https://i.imgur.com/dge4kFJ.png
+
+# From Paul Eggert (2019-07-11):
+# "Hong Kong winter time" is considered to be daylight saving.
+# "Hong Kong had adopted daylight saving on June 15 as a wartime measure,
+# clocks moving forward one hour until October 1, when they would be put back
+# by just half an hour for 'Hong Kong Winter time', so that daylight saving
+# operated year round." -- Low Z. The longest day: when wartime Hong Kong
+# introduced daylight saving. South China Morning Post. 2019-06-28.
+# https://www.scmp.com/magazines/post-magazine/short-reads/article/3016281/longest-day-when-wartime-hong-kong-introduced
+
+# From P Chan (2018-12-31):
+# * According to the Hong Kong Daylight-Saving Regulations, 1941, the
+#   1941 spring-forward transition was at 03:00.
+#	http://sunzi.lib.hku.hk/hkgro/view/g1941/304271.pdf
+#	http://sunzi.lib.hku.hk/hkgro/view/g1941/305516.pdf
+# * According to some articles from South China Morning Post, +08 was
+#   resumed on 1945-11-18 at 02:00.
+#	https://i.imgur.com/M2IsZ3c.png
+#	https://i.imgur.com/iOPqrVo.png
+#	https://i.imgur.com/fffcGDs.png
+# * Some newspapers ... said the 1946 spring-forward transition was on
+#   04-21 at 00:00.  The Kung Sheung Evening News 1946-04-20 (Chinese)
+#	https://i.imgur.com/ZSzent0.png
+#	https://mmis.hkpl.gov.hk///c/portal/cover?c=QF757YsWv5%2FH7zGe%2FKF%2BFLYsuqGhRBfe p.4
+#   The Kung Sheung Daily News 1946-04-21 (Chinese)
+#	https://i.imgur.com/7ecmRlcm.png
+#	https://mmis.hkpl.gov.hk///c/portal/cover?c=QF757YsWv5%2BQBGt1%2BwUj5qG2GqtwR3Wh p.4
+# * According to the Summer Time Ordinance (1946), the fallback
+#   transitions between 1946 and 1952 were at 03:30 Standard Time (+08)
+#	http://oelawhk.lib.hku.hk/archive/files/bb74b06a74d5294620a15de560ab33c6.pdf
+# * Some other laws and regulations related to DST from 1953 to 1979
+#   Summer Time Ordinance 1953
+#	https://i.imgur.com/IOlJMav.jpg
+#   Summer Time (Amendment) Ordinance 1965
+#	https://i.imgur.com/8rofeLa.jpg
+#   Interpretation and General Clauses Ordinance (1966)
+#	https://i.imgur.com/joy3msj.jpg
+#   Emergency (Summer Time) Regulation 1973 <https://i.imgur.com/OpRWrKz.jpg>
+#   Interpretation and General Clauses (Amendment) Ordinance 1977
+#	https://i.imgur.com/RaNqnc4.jpg
+#   Resolution of the Legislative Council passed on 9 May 1979
+#	https://www.legco.gov.hk/yr78-79/english/lc_sitg/hansard/h790509.pdf#page=39
+
+# From Paul Eggert (2019-05-31):
+# Here are the dates given at
+# https://www.hko.gov.hk/gts/time/Summertime.htm
+# as of 2014-06-19:
+# Year        Period
+# 1941        15 Jun to 30 Sep
+# 1942        Whole year
+# 1943        Whole year
+# 1944        Whole year
+# 1945        Whole year
+# 1946        20 Apr to 1 Dec
+# 1947        13 Apr to 30 Nov
+# 1948        2 May to 31 Oct
+# 1949        3 Apr to 30 Oct
+# 1950        2 Apr to 29 Oct
+# 1951        1 Apr to 28 Oct
+# 1952        6 Apr to 2 Nov
+# 1953        5 Apr to 1 Nov
+# 1954        21 Mar to 31 Oct
+# 1955        20 Mar to 6 Nov
+# 1956        18 Mar to 4 Nov
+# 1957        24 Mar to 3 Nov
+# 1958        23 Mar to 2 Nov
+# 1959        22 Mar to 1 Nov
+# 1960        20 Mar to 6 Nov
+# 1961        19 Mar to 5 Nov
+# 1962        18 Mar to 4 Nov
+# 1963        24 Mar to 3 Nov
+# 1964        22 Mar to 1 Nov
+# 1965        18 Apr to 17 Oct
+# 1966        17 Apr to 16 Oct
+# 1967        16 Apr to 22 Oct
+# 1968        21 Apr to 20 Oct
+# 1969        20 Apr to 19 Oct
+# 1970        19 Apr to 18 Oct
+# 1971        18 Apr to 17 Oct
+# 1972        16 Apr to 22 Oct
+# 1973        22 Apr to 21 Oct
+# 1973/74     30 Dec 73 to 20 Oct 74
+# 1975        20 Apr to 19 Oct
+# 1976        18 Apr to 17 Oct
+# 1977        Nil
+# 1978        Nil
+# 1979        13 May to 21 Oct
+# 1980 to Now Nil
+# The page does not give times of day for transitions,
+# or dates for the 1942 and 1945 transitions.
+# The Japanese occupation of Hong Kong began 1941-12-25.
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	HK	1946	only	-	Apr	21	0:00	1:00	S
+Rule	HK	1946	only	-	Dec	1	3:30s	0	-
+Rule	HK	1947	only	-	Apr	13	3:30s	1:00	S
+Rule	HK	1947	only	-	Nov	30	3:30s	0	-
+Rule	HK	1948	only	-	May	2	3:30s	1:00	S
+Rule	HK	1948	1952	-	Oct	Sun>=28	3:30s	0	-
+Rule	HK	1949	1953	-	Apr	Sun>=1	3:30	1:00	S
+Rule	HK	1953	1964	-	Oct	Sun>=31	3:30	0	-
+Rule	HK	1954	1964	-	Mar	Sun>=18	3:30	1:00	S
+Rule	HK	1965	1976	-	Apr	Sun>=16	3:30	1:00	S
+Rule	HK	1965	1976	-	Oct	Sun>=16	3:30	0	-
+Rule	HK	1973	only	-	Dec	30	3:30	1:00	S
+Rule	HK	1979	only	-	May	13	3:30	1:00	S
+Rule	HK	1979	only	-	Oct	21	3:30	0	-
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Hong_Kong	7:36:42 -	LMT	1904 Oct 30  0:36:42
+			8:00	-	HKT	1941 Jun 15  3:00
+			8:00	1:00	HKST	1941 Oct  1  4:00
+			8:00	0:30	HKWT	1941 Dec 25
+			9:00	-	JST	1945 Nov 18  2:00
+			8:00	HK	HK%sT
+
+###############################################################################
+
+# Taiwan
+
+# From smallufo (2010-04-03):
+# According to Taiwan's CWB [Central Weather Bureau],
+# http://www.cwb.gov.tw/V6/astronomy/cdata/summert.htm
+# Taipei has DST in 1979 between July 1st and Sep 30.
+
+# From Yu-Cheng Chuang (2013-07-12):
+# On Dec 28, 1895, the Meiji Emperor announced Ordinance No. 167 of
+# Meiji Year 28 "The clause about standard time", mentioned that
+# Taiwan and Penghu Islands, as well as Yaeyama and Miyako Islands
+# (both in Okinawa) adopt the Western Standard Time which is based on
+# 120E. The adoption began from Jan 1, 1896. The original text can be
+# found on Wikisource:
+# https://ja.wikisource.org/wiki/標準時ニ關スル件_(公布時)
+# ... This could be the first adoption of time zone in Taiwan, because
+# during the Qing Dynasty, it seems that there was no time zone
+# declared officially.
+#
+# Later, in the beginning of World War II, on Sep 25, 1937, the Showa
+# Emperor announced Ordinance No. 529 of Showa Year 12 "The clause of
+# revision in the ordinance No. 167 of Meiji year 28 about standard
+# time", in which abolished the adoption of Western Standard Time in
+# western islands (listed above), which means the whole Japan
+# territory, including later occupations, adopt Japan Central Time
+# (UT+9). The adoption began on Oct 1, 1937. The original text can
+# be found on Wikisource:
+# https://ja.wikisource.org/wiki/明治二十八年勅令第百六十七號標準時ニ關スル件中改正ノ件
+#
+# That is, the time zone of Taipei switched to UT+9 on Oct 1, 1937.
+
+# From Yu-Cheng Chuang (2014-07-02):
+# I've found more evidence about when the time zone was switched from UT+9
+# back to UT+8 after WW2.  I believe it was on Sep 21, 1945.  In a document
+# during Japanese era [1] in which the officer told the staff to change time
+# zone back to Western Standard Time (UT+8) on Sep 21.  And in another
+# history page of National Cheng Kung University [2], on Sep 21 there is a
+# note "from today, switch back to Western Standard Time".  From these two
+# materials, I believe that the time zone change happened on Sep 21.  And
+# today I have found another monthly journal called "The Astronomical Herald"
+# from The Astronomical Society of Japan [3] in which it mentioned the fact
+# that:
+#
+# 1. Standard Time of the Country (Japan) was adopted on Jan 1, 1888, using
+# the time at 135E (GMT+9)
+#
+# 2. Standard Time of the Country was renamed to Central Standard Time, on Jan
+# 1, 1898, and on the same day, the new territories Taiwan and Penghu islands,
+# as well as Yaeyama and Miyako islands, adopted a new time zone called
+# Western Standard Time, which is in GMT+8.
+#
+# 3. Western Standard Time was deprecated on Sep 30, 1937. From then all the
+# territories of Japan adopted the same time zone, which is Central Standard
+# Time.
+#
+# [1] Academica Historica, Taiwan:
+# http://163.29.208.22:8080/govsaleShowImage/connect_img.php?s=00101738900090036&e=00101738900090037
+# [2] Nat'l Cheng Kung University 70th Anniversary Special Site:
+# http://www.ncku.edu.tw/~ncku70/menu/001/01_01.htm
+# [3] Yukio Niimi, The Standard Time in Japan (1997), p.475:
+# http://www.asj.or.jp/geppou/archive_open/1997/pdf/19971001c.pdf
+
+# Yu-Cheng Chuang (2014-07-03):
+# I finally have found the real official gazette about changing back to
+# Western Standard Time on Sep 21 in Taiwan.  It's Taiwan Governor-General
+# Bulletin No. 386 in Showa 20 years (1945), published on Sep 19, 1945. [1] ...
+# [It] abolishes Bulletin No. 207 in Showa 12 years (1937), which is a local
+# bulletin in Taiwan for that Ordinance No. 529. It also mentioned that 1am on
+# Sep 21, 1945 will be 12am on Sep 21.  I think this bulletin is much more
+# official than the one I mentioned in my first mail, because it's from the
+# top-level government in Taiwan. If you're going to quote any resource, this
+# would be a good one.
+# [1] Taiwan Governor-General Gazette, No. 1018, Sep 19, 1945:
+# http://db2.th.gov.tw/db2/view/viewImg.php?imgcode=0072031018a&num=19&bgn=019&end=019&otherImg=&type=gener
+
+# From Yu-Cheng Chuang (2014-07-02):
+# In 1946, DST in Taiwan was from May 15 and ended on Sep 30. The info from
+# Central Weather Bureau website was not correct.
+#
+# Original Bulletin:
+# http://subtpg.tpg.gov.tw/og/image2.asp?f=03502F0AKM1AF
+# http://subtpg.tpg.gov.tw/og/image2.asp?f=0350300AKM1B0 (cont.)
+#
+# In 1947, DST in Taiwan was expanded to Oct 31. There is a backup of that
+# telegram announcement from Taiwan Province Government:
+#
+# http://subtpg.tpg.gov.tw/og/image2.asp?f=0360310AKZ431
+#
+# Here is a brief translation:
+#
+#   The Summer Time this year is adopted from midnight Apr 15 until Sep 20
+#   midnight. To save (energy?) consumption, we're expanding Summer Time
+#   adoption till Oct 31 midnight.
+#
+# The Central Weather Bureau website didn't mention that, however it can
+# be found from historical government announcement database.
+
+# From Paul Eggert (2014-07-03):
+# As per Yu-Cheng Chuang, say that Taiwan was at UT +09 from 1937-10-01
+# until 1945-09-21 at 01:00, overriding Shanks & Pottenger.
+# Likewise, use Yu-Cheng Chuang's data for DST in Taiwan.
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Taiwan	1946	only	-	May	15	0:00	1:00	D
+Rule	Taiwan	1946	only	-	Oct	1	0:00	0	S
+Rule	Taiwan	1947	only	-	Apr	15	0:00	1:00	D
+Rule	Taiwan	1947	only	-	Nov	1	0:00	0	S
+Rule	Taiwan	1948	1951	-	May	1	0:00	1:00	D
+Rule	Taiwan	1948	1951	-	Oct	1	0:00	0	S
+Rule	Taiwan	1952	only	-	Mar	1	0:00	1:00	D
+Rule	Taiwan	1952	1954	-	Nov	1	0:00	0	S
+Rule	Taiwan	1953	1959	-	Apr	1	0:00	1:00	D
+Rule	Taiwan	1955	1961	-	Oct	1	0:00	0	S
+Rule	Taiwan	1960	1961	-	Jun	1	0:00	1:00	D
+Rule	Taiwan	1974	1975	-	Apr	1	0:00	1:00	D
+Rule	Taiwan	1974	1975	-	Oct	1	0:00	0	S
+Rule	Taiwan	1979	only	-	Jul	1	0:00	1:00	D
+Rule	Taiwan	1979	only	-	Oct	1	0:00	0	S
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+# Taipei or Taibei or T'ai-pei
+Zone	Asia/Taipei	8:06:00 -	LMT	1896 Jan  1
+			8:00	-	CST	1937 Oct  1
+			9:00	-	JST	1945 Sep 21  1:00
+			8:00	Taiwan	C%sT
+
+# Macau (Macao, Aomen)
+#
+# From P Chan (2018-05-10):
+# * LegisMac
+#   http://legismac.safp.gov.mo/legismac/descqry/Descqry.jsf?lang=pt
+#   A database for searching titles of legal documents of Macau in
+#   Chinese and Portuguese.  The term "HORÁRIO DE VERÃO" can be used for
+#   searching decrees about summer time.
+# * Archives of Macao
+#   http://www.archives.gov.mo/en/bo/
+#   It contains images of old official gazettes.
+# * The Macao Meteorological and Geophysical Bureau have a page listing the
+#   summer time history.  But it is not complete and has some mistakes.
+#   http://www.smg.gov.mo/smg/geophysics/e_t_Summer%20Time.htm
+# Macau adopted GMT+8 on 30 Oct 1904 to follow Hong Kong.  Clocks were
+# advanced by 25 minutes and 50 seconds.  Which means the LMT used was
+# +7:34:10.  As stated in the "Portaria No. 204" dated 21 October 1904
+# and published in the Official Gazette on 29 October 1904.
+# http://igallery.icm.gov.mo/Images/Archives/BO/MO_AH_PUB_BO_1904_10/MO_AH_PUB_BO_1904_10_00025_Grey.JPG
+#
+# Therefore the 1911 decree of Portugal did not change time in Macau.
+#
+# From LegisMac, here is a list of decrees that changed the time ...
+# [Decree Gazette-no. date; titles omitted in this quotation]
+#	DIL 732 BOCM 51 1941.12.20
+#	DIL 764 BOCM 9S 1942.04.30
+#	DIL 781 BOCM 21 1942.10.10
+#	PT 3434 BOCM 8S 1943.04.17
+#	PT 3504 BOCM 20 1943.09.25
+#	PT 3843 BOCM 39 1945.09.29
+#	PT 3961 BOCM 17 1946.04.27
+#	PT 4026 BOCM 39 1946.09.28
+#	PT 4153 BOCM 16 1947.04.10
+#	PT 4271 BOCM 48 1947.11.29
+#	PT 4374 BOCM 18 1948.05.01
+#	PT 4465 BOCM 44 1948.10.30
+#	PT 4590 BOCM 14 1949.04.02
+#	PT 4666 BOCM 44 1949.10.29
+#	PT 4771 BOCM 12 1950.03.25
+#	PT 4838 BOCM 43 1950.10.28
+#	PT 4946 BOCM 12 1951.03.24
+#	PT 5025 BO 43 1951.10.27
+#	PT 5149 BO 14 1952.04.05
+#	PT 5251 BO 43 1952.10.25
+#	PT 5366 BO 13 1953.03.28
+#	PT 5444 BO 44 1953.10.31
+#	PT 5540 BO 12 1954.03.20
+#	PT 5589 BO 44 1954.10.30
+#	PT 5676 BO 12 1955.03.19
+#	PT 5739 BO 45 1955.11.05
+#	PT 5823 BO 11 1956.03.17
+#	PT 5891 BO 44 1956.11.03
+#	PT 5981 BO 12 1957.03.23
+#	PT 6064 BO 43 1957.10.26
+#	PT 6172 BO 12 1958.03.22
+#	PT 6243 BO 43 1958.10.25
+#	PT 6341 BO 12 1959.03.21
+#	PT 6411 BO 43 1959.10.24
+#	PT 6514 BO 11 1960.03.12
+#	PT 6584 BO 44 1960.10.29
+#	PT 6721 BO 10 1961.03.11
+#	PT 6815 BO 43 1961.10.28
+#	PT 6947 BO 10 1962.03.10
+#	PT 7080 BO 43 1962.10.27
+#	PT 7218 BO 12 1963.03.23
+#	PT 7340 BO 43 1963.10.26
+#	PT 7491 BO 11 1964.03.14
+#	PT 7664 BO 43 1964.10.24
+#	PT 7846 BO 15 1965.04.10
+#	PT 7979 BO 42 1965.10.16
+#	PT 8146 BO 15 1966.04.09
+#	PT 8252 BO 41 1966.10.08
+#	PT 8429 BO 15 1967.04.15
+#	PT 8540 BO 41 1967.10.14
+#	PT 8735 BO 15 1968.04.13
+#	PT 8860 BO 41 1968.10.12
+#	PT 9035 BO 16 1969.04.19
+#	PT 9156 BO 42 1969.10.18
+#	PT 9328 BO 15 1970.04.11
+#	PT 9418 BO 41 1970.10.10
+#	PT 9587 BO 14 1971.04.03
+#	PT 9702 BO 41 1971.10.09
+#	PT 38-A/72 BO 14 1972.04.01
+#	PT 126-A/72 BO 41 1972.10.07
+#	PT 61/73 BO 14 1973.04.07
+#	PT 182/73 BO 40 1973.10.06
+#	PT 282/73 BO 51 1973.12.22
+#	PT 177/74 BO 41 1974.10.12
+#	PT 51/75 BO 15 1975.04.12
+#	PT 173/75 BO 41 1975.10.11
+#	PT 67/76/M BO 14 1976.04.03
+#	PT 169/76/M BO 41 1976.10.09
+#	PT 78/79/M BO 19 1979.05.12
+#	PT 166/79/M BO 42 1979.10.20
+# Note that DIL 732 does not belong to "HORÁRIO DE VERÃO" according to
+# LegisMac.... Note that between 1942 and 1945, the time switched
+# between GMT+9 and GMT+10.  Also in 1965 and 1965 the DST ended at 2:30am.
+
+# From Paul Eggert (2018-05-10):
+# The 1904 decree says that Macau changed from the meridian of
+# Fortaleza do Monte, presumably the basis for the 7:34:10 for LMT.
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Macau	1942	1943	-	Apr	30	23:00	1:00	-
+Rule	Macau	1942	only	-	Nov	17	23:00	0	-
+Rule	Macau	1943	only	-	Sep	30	23:00	0	S
+Rule	Macau	1946	only	-	Apr	30	23:00s	1:00	D
+Rule	Macau	1946	only	-	Sep	30	23:00s	0	S
+Rule	Macau	1947	only	-	Apr	19	23:00s	1:00	D
+Rule	Macau	1947	only	-	Nov	30	23:00s	0	S
+Rule	Macau	1948	only	-	May	 2	23:00s	1:00	D
+Rule	Macau	1948	only	-	Oct	31	23:00s	0	S
+Rule	Macau	1949	1950	-	Apr	Sat>=1	23:00s	1:00	D
+Rule	Macau	1949	1950	-	Oct	lastSat	23:00s	0	S
+Rule	Macau	1951	only	-	Mar	31	23:00s	1:00	D
+Rule	Macau	1951	only	-	Oct	28	23:00s	0	S
+Rule	Macau	1952	1953	-	Apr	Sat>=1	23:00s	1:00	D
+Rule	Macau	1952	only	-	Nov	 1	23:00s	0	S
+Rule	Macau	1953	1954	-	Oct	lastSat	23:00s	0	S
+Rule	Macau	1954	1956	-	Mar	Sat>=17	23:00s	1:00	D
+Rule	Macau	1955	only	-	Nov	 5	23:00s	0	S
+Rule	Macau	1956	1964	-	Nov	Sun>=1	03:30	0	S
+Rule	Macau	1957	1964	-	Mar	Sun>=18	03:30	1:00	D
+Rule	Macau	1965	1973	-	Apr	Sun>=16	03:30	1:00	D
+Rule	Macau	1965	1966	-	Oct	Sun>=16	02:30	0	S
+Rule	Macau	1967	1976	-	Oct	Sun>=16	03:30	0	S
+Rule	Macau	1973	only	-	Dec	30	03:30	1:00	D
+Rule	Macau	1975	1976	-	Apr	Sun>=16	03:30	1:00	D
+Rule	Macau	1979	only	-	May	13	03:30	1:00	D
+Rule	Macau	1979	only	-	Oct	Sun>=16	03:30	0	S
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Macau	7:34:10 -	LMT	1904 Oct 30
+			8:00	-	CST	1941 Dec 21 23:00
+			9:00	Macau	+09/+10	1945 Sep 30 24:00
+			8:00	Macau	C%sT
+
+
+###############################################################################
+
+# Cyprus
+
+# Milne says the Eastern Telegraph Company used 2:14:00.  Stick with LMT.
+# IATA SSIM (1998-09) has Cyprus using EU rules for the first time.
+
+# From Paul Eggert (2016-09-09):
+# Yesterday's Cyprus Mail reports that Northern Cyprus followed Turkey's
+# lead and switched from +02/+03 to +03 year-round.
+# http://cyprus-mail.com/2016/09/08/two-time-zones-cyprus-turkey-will-not-turn-clocks-back-next-month/
+#
+# From Even Scharning (2016-10-31):
+# Looks like the time zone split in Cyprus went through last night.
+# http://cyprus-mail.com/2016/10/30/cyprus-new-division-two-time-zones-now-reality/
+
+# From Paul Eggert (2017-10-18):
+# Northern Cyprus will reinstate winter time on October 29, thus
+# staying in sync with the rest of Cyprus.  See: Anastasiou A.
+# Cyprus to remain united in time.  Cyprus Mail 2017-10-17.
+# https://cyprus-mail.com/2017/10/17/cyprus-remain-united-time/
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Cyprus	1975	only	-	Apr	13	0:00	1:00	S
+Rule	Cyprus	1975	only	-	Oct	12	0:00	0	-
+Rule	Cyprus	1976	only	-	May	15	0:00	1:00	S
+Rule	Cyprus	1976	only	-	Oct	11	0:00	0	-
+Rule	Cyprus	1977	1980	-	Apr	Sun>=1	0:00	1:00	S
+Rule	Cyprus	1977	only	-	Sep	25	0:00	0	-
+Rule	Cyprus	1978	only	-	Oct	2	0:00	0	-
+Rule	Cyprus	1979	1997	-	Sep	lastSun	0:00	0	-
+Rule	Cyprus	1981	1998	-	Mar	lastSun	0:00	1:00	S
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Nicosia	2:13:28 -	LMT	1921 Nov 14
+			2:00	Cyprus	EE%sT	1998 Sep
+			2:00	EUAsia	EE%sT
+Zone	Asia/Famagusta	2:15:48	-	LMT	1921 Nov 14
+			2:00	Cyprus	EE%sT	1998 Sep
+			2:00	EUAsia	EE%sT	2016 Sep  8
+			3:00	-	+03	2017 Oct 29 1:00u
+			2:00	EUAsia	EE%sT
+
+# Classically, Cyprus belongs to Asia; e.g. see Herodotus, Histories, I.72.
+# However, for various reasons many users expect to find it under Europe.
+Link	Asia/Nicosia	Europe/Nicosia
+
+# Georgia
+# From Paul Eggert (1994-11-19):
+# Today's _Economist_ (p 60) reports that Georgia moved its clocks forward
+# an hour recently, due to a law proposed by Zurab Murvanidze,
+# an MP who went on a hunger strike for 11 days to force discussion about it!
+# We have no details, but we'll guess they didn't move the clocks back in fall.
+#
+# From Mathew Englander, quoting AP (1996-10-23 13:05-04):
+# Instead of putting back clocks at the end of October, Georgia
+# will stay on daylight savings time this winter to save energy,
+# President Eduard Shevardnadze decreed Wednesday.
+#
+# From the BBC via Joseph S. Myers (2004-06-27):
+#
+# Georgia moved closer to Western Europe on Sunday...  The former Soviet
+# republic has changed its time zone back to that of Moscow.  As a result it
+# is now just four hours ahead of Greenwich Mean Time, rather than five hours
+# ahead.  The switch was decreed by the pro-Western president of Georgia,
+# Mikheil Saakashvili, who said the change was partly prompted by the process
+# of integration into Europe.
+
+# From Teimuraz Abashidze (2005-11-07):
+# Government of Georgia ... decided to NOT CHANGE daylight savings time on
+# [Oct.] 30, as it was done before during last more than 10 years.
+# Currently, we are in fact GMT +4:00, as before 30 October it was GMT
+# +3:00.... The problem is, there is NO FORMAL LAW or governmental document
+# about it.  As far as I can find, I was told, that there is no document,
+# because we just DIDN'T ISSUE document about switching to winter time....
+# I don't know what can be done, especially knowing that some years ago our
+# DST rules where changed THREE TIMES during one month.
+
+# Milne 1899 says Tbilisi (Tiflis) time was 2:59:05.7.
+# Byalokoz 1919 says Georgia was 2:59:11.
+# Go with Byalokoz.
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Tbilisi	2:59:11 -	LMT	1880
+			2:59:11	-	TBMT	1924 May  2 # Tbilisi Mean Time
+			3:00	-	+03	1957 Mar
+			4:00 RussiaAsia +04/+05	1991 Mar 31  2:00s
+			3:00 RussiaAsia +03/+04	1992
+			3:00 E-EurAsia	+03/+04	1994 Sep lastSun
+			4:00 E-EurAsia	+04/+05	1996 Oct lastSun
+			4:00	1:00	+05	1997 Mar lastSun
+			4:00 E-EurAsia	+04/+05	2004 Jun 27
+			3:00 RussiaAsia	+03/+04	2005 Mar lastSun  2:00
+			4:00	-	+04
+
+# East Timor
+
+# See Indonesia for the 1945 transition.
+
+# From João Carrascalão, brother of the former governor of East Timor, in
+# East Timor may be late for its millennium
+# <https://etan.org/et99c/december/26-31/30ETMAY.htm> (1999-12-26/31):
+# Portugal tried to change the time forward in 1974 because the sun
+# rises too early but the suggestion raised a lot of problems with the
+# Timorese and I still don't think it would work today because it
+# conflicts with their way of life.
+
+# From Paul Eggert (2000-12-04):
+# We don't have any record of the above attempt.
+# Most likely our records are incomplete, but we have no better data.
+
+# From Manoel de Almeida e Silva, Deputy Spokesman for the UN Secretary-General
+# http://www.hri.org/news/world/undh/2000/00-08-16.undh.html
+# (2000-08-16):
+# The Cabinet of the East Timor Transition Administration decided
+# today to advance East Timor's time by one hour.  The time change,
+# which will be permanent, with no seasonal adjustment, will happen at
+# midnight on Saturday, September 16.
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Dili	8:22:20 -	LMT	1912 Jan  1
+			8:00	-	+08	1942 Feb 21 23:00
+			9:00	-	+09	1976 May  3
+			8:00	-	+08	2000 Sep 17  0:00
+			9:00	-	+09
+
+# India
+
+# British astronomer Henry Park Hollis disliked India Standard Time's offset:
+# "A new time system has been proposed for India, Further India, and Burmah.
+# The scheme suggested is that the times of the meridians 5½ and 6½ hours
+# east of Greenwich should be adopted in these territories.  No reason is
+# given why hourly meridians five hours and six hours east should not be
+# chosen; a plan which would bring the time of India into harmony with
+# that of almost the whole of the civilised world."
+# Hollis HP. Universal Time, Longitudes, and Geodesy. Mon Not R Astron Soc.
+# 1905-02-10;65(4):405-6. https://doi.org/10.1093/mnras/65.4.382
+
+# From Ian P. Beacock, in "A brief history of (modern) time", The Atlantic
+# https://www.theatlantic.com/technology/archive/2015/12/the-creation-of-modern-time/421419/
+# (2015-12-22):
+# In January 1906, several thousand cotton-mill workers rioted on the
+# outskirts of Bombay....  They were protesting the proposed abolition of
+# local time in favor of Indian Standard Time....  Journalists called this
+# dispute the "Battle of the Clocks."  It lasted nearly half a century.
+
+# From Paul Eggert (2017-04-20):
+# Good luck trying to nail down old timekeeping records in India.
+# "... in the nineteenth century ... Madras Observatory took its magnetic
+# measurements on Göttingen time, its meteorological measurements on Madras
+# (local) time, dropped its time ball on Greenwich (ocean navigator's) time,
+# and distributed civil (local time)." -- Bartky IR. Selling the true time:
+# 19th-century timekeeping in america. Stanford U Press (2000), 247 note 19.
+# "A more potent cause of resistance to the general adoption of the present
+# standard time lies in the fact that it is Madras time.  The citizen of
+# Bombay, proud of being 'primus in Indis' and of Calcutta, equally proud of
+# his city being the Capital of India, and - for a part of the year - the Seat
+# of the Supreme Government, alike look down on Madras, and refuse to change
+# the time they are using, for that of what they regard as a benighted
+# Presidency; while Madras, having for long given the standard time to the
+# rest of India, would resist the adoption of any other Indian standard in its
+# place." -- Oldham RD. On Time in India: a suggestion for its improvement.
+# Proceedings of the Asiatic Society of Bengal (April 1899), 49-55.
+#
+# "In 1870 ... Madras time - 'now used by the telegraph and regulated from the
+# only government observatory' - was suggested as a standard railway time,
+# first to be adopted on the Great Indian Peninsular Railway (GIPR)....
+# Calcutta, Bombay, and Karachi, were to be allowed to continue with their
+# local time for civil purposes." - Prasad R. Tracks of Change: Railways and
+# Everyday Life in Colonial India. Cambridge University Press (2016), 145.
+#
+# Reed S, Low F. The Indian Year Book 1936-37. Bennett, Coleman, pp 27-8.
+# https://archive.org/details/in.ernet.dli.2015.282212
+# This lists +052110 as Madras local time used in railways, and says that on
+# 1906-01-01 railways and telegraphs in India switched to +0530.  Some
+# municipalities retained their former time, and the time in Calcutta
+# continued to depend on whether you were at the railway station or at
+# government offices.  Government time was at +055320 (according to Shanks) or
+# at +0554 (according to the Indian Year Book).  Railway time is more
+# appropriate for our purposes, as it was better documented, it is what we do
+# elsewhere (e.g., Europe/London before 1880), and after 1906 it was
+# consistent in the region now identified by Asia/Kolkata.  So, use railway
+# time for 1870-1941.  Shanks is our only (and dubious) source for the
+# 1941-1945 data.
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Kolkata	5:53:28 -	LMT	1854 Jun 28 # Kolkata
+			5:53:20	-	HMT	1870	    # Howrah Mean Time?
+			5:21:10	-	MMT	1906 Jan  1 # Madras local time
+			5:30	-	IST	1941 Oct
+			5:30	1:00	+0630	1942 May 15
+			5:30	-	IST	1942 Sep
+			5:30	1:00	+0630	1945 Oct 15
+			5:30	-	IST
+# Since 1970 the following are like Asia/Kolkata:
+#	Andaman Is
+#	Lakshadweep (Laccadive, Minicoy and Amindivi Is)
+#	Nicobar Is
+
+# Indonesia
+#
+# From Paul Eggert (2014-09-06):
+# The 1876 Report of the Secretary of the [US] Navy, p 306 says that Batavia
+# civil time was 7:07:12.5; round to even for Jakarta.
+#
+# From Gwillim Law (2001-05-28), overriding Shanks & Pottenger:
+# http://www.sumatera-inc.com/go_to_invest/about_indonesia.asp#standtime
+# says that Indonesia's time zones changed on 1988-01-01.  Looking at some
+# time zone maps, I think that must refer to Western Borneo (Kalimantan Barat
+# and Kalimantan Tengah) switching from UTC+8 to UTC+7.
+#
+# From Paul Eggert (2007-03-10):
+# Here is another correction to Shanks & Pottenger.
+# JohnTWB writes that Japanese forces did not surrender control in
+# Indonesia until 1945-09-01 00:00 at the earliest (in Jakarta) and
+# other formal surrender ceremonies were September 9, 11, and 13, plus
+# September 12 for the regional surrender to Mountbatten in Singapore.
+# These would be the earliest possible times for a change.
+# Régimes horaires pour le monde entier, by Henri Le Corre, (Éditions
+# Traditionnelles, 1987, Paris) says that Java and Madura switched
+# from UT +09 to +07:30 on 1945-09-23, and gives 1944-09-01 for Jayapura
+# (Hollandia).  For now, assume all Indonesian locations other than Jayapura
+# switched on 1945-09-23.
+#
+# From Paul Eggert (2013-08-11):
+# Normally the tz database uses English-language abbreviations, but in
+# Indonesia it's typical to use Indonesian-language abbreviations even
+# when writing in English.  For example, see the English-language
+# summary published by the Time and Frequency Laboratory of the
+# Research Center for Calibration, Instrumentation and Metrology,
+# Indonesia, <http://time.kim.lipi.go.id/time-eng.php> (2006-09-29).
+# The time zone abbreviations and UT offsets are:
+#
+# WIB  - +07 - Waktu Indonesia Barat (Indonesia western time)
+# WITA - +08 - Waktu Indonesia Tengah (Indonesia central time)
+# WIT  - +09 - Waktu Indonesia Timur (Indonesia eastern time)
+#
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+# Java, Sumatra
+Zone Asia/Jakarta	7:07:12 -	LMT	1867 Aug 10
+# Shanks & Pottenger say the next transition was at 1924 Jan 1 0:13,
+# but this must be a typo.
+			7:07:12	-	BMT	1923 Dec 31 23:47:12 # Batavia
+			7:20	-	+0720	1932 Nov
+			7:30	-	+0730	1942 Mar 23
+			9:00	-	+09	1945 Sep 23
+			7:30	-	+0730	1948 May
+			8:00	-	+08	1950 May
+			7:30	-	+0730	1964
+			7:00	-	WIB
+# west and central Borneo
+Zone Asia/Pontianak	7:17:20	-	LMT	1908 May
+			7:17:20	-	PMT	1932 Nov    # Pontianak MT
+			7:30	-	+0730	1942 Jan 29
+			9:00	-	+09	1945 Sep 23
+			7:30	-	+0730	1948 May
+			8:00	-	+08	1950 May
+			7:30	-	+0730	1964
+			8:00	-	WITA	1988 Jan  1
+			7:00	-	WIB
+# Sulawesi, Lesser Sundas, east and south Borneo
+Zone Asia/Makassar	7:57:36 -	LMT	1920
+			7:57:36	-	MMT	1932 Nov    # Macassar MT
+			8:00	-	+08	1942 Feb  9
+			9:00	-	+09	1945 Sep 23
+			8:00	-	WITA
+# Maluku Islands, West Papua, Papua
+Zone Asia/Jayapura	9:22:48 -	LMT	1932 Nov
+			9:00	-	+09	1944 Sep  1
+			9:30	-	+0930	1964
+			9:00	-	WIT
+
+# Iran
+
+# From Roozbeh Pournader (2003-03-15):
+# This is an English translation of what I just found (originally in Persian).
+# The Gregorian dates in brackets are mine:
+#
+#	Official Newspaper No. 13548-1370/6/25 [1991-09-16]
+#	No. 16760/T233 H				1370/6/10 [1991-09-01]
+#
+#	The Rule About Change of the Official Time of the Country
+#
+#	The Board of Ministers, in the meeting dated 1370/5/23 [1991-08-14],
+#	based on the suggestion number 2221/D dated 1370/4/22 [1991-07-13]
+#	of the Country's Organization for Official and Employment Affairs,
+#	and referring to the law for equating the working hours of workers
+#	and officers in the whole country dated 1359/4/23 [1980-07-14], and
+#	for synchronizing the official times of the country, agreed that:
+#
+#	The official time of the country will should move forward one hour
+#	at the 24[:00] hours of the first day of Farvardin and should return
+#	to its previous state at the 24[:00] hours of the 30th day of
+#	Shahrivar.
+#
+#	First Deputy to the President - Hassan Habibi
+#
+# From personal experience, that agrees with what has been followed
+# for at least the last 5 years.  Before that, for a few years, the
+# date used was the first Thursday night of Farvardin and the last
+# Thursday night of Shahrivar, but I can't give exact dates....
+#
+# From Roozbeh Pournader (2005-04-05):
+# The text of the Iranian law, in effect since 1925, clearly mentions
+# that the true solar year is the measure, and there is no arithmetic
+# leap year calculation involved.  There has never been any serious
+# plan to change that law....
+#
+# From Paul Eggert (2018-11-30):
+# Go with Shanks & Pottenger before Sept. 1991, and with Pournader thereafter.
+# I used the following code in GNU Emacs 26.1 to generate the "Rule Iran"
+# lines from 2008 through 2087.  Emacs 26.1 uses Ed Reingold's
+# cal-persia implementation of Birashk's approximation, which in the
+# 2008-2087 range disagrees with the astronomical Persian calendar
+# for Persian years 1404 (Gregorian 2025) and 1437 (Gregorian 2058), so
+# the following code special-cases those years.  See Table 15.1, page 264, of:
+# Edward M. Reingold and Nachum Dershowitz, Calendrical Calculations:
+# The Ultimate Edition, Cambridge University Press (2018).
+# https://www.cambridge.org/fr/academic/subjects/computer-science/computing-general-interest/calendrical-calculations-ultimate-edition-4th-edition
+# Page 258, footnote 2, of this book says there is some dispute over what will
+# happen in 2091 (and some other years after that), so this code
+# stops in 2087, as 2088 and 2089 agree with the "max" rule below.
+# (cl-loop
+#  initially (require 'cal-persia)
+#  with first-persian-year = 1387
+#  with last-persian-year = 1466
+#  ;; Exceptional years in the above range,
+#  ;; from Reingold & Dershowitz Table 15.1, page 264:
+#  with exceptional-persian-years = '(1404 1437)
+#  with range-start = nil
+#  for persian-year from first-persian-year to last-persian-year
+#  do
+#  (let*
+#      ((exceptional-year-offset
+#        (if (member persian-year exceptional-persian-years) 1 0))
+#       (beg-dst-absolute
+#        (+ (calendar-persian-to-absolute (list 1 1 persian-year))
+#           exceptional-year-offset))
+#       (end-dst-absolute
+#        (+ (calendar-persian-to-absolute (list 6 30 persian-year))
+#           exceptional-year-offset))
+#       (next-year-beg-dst-absolute
+#        (+ (calendar-persian-to-absolute (list 1 1 (1+ persian-year)))
+#           (if (member (1+ persian-year) exceptional-persian-years) 1 0)))
+#       (beg-dst (calendar-gregorian-from-absolute beg-dst-absolute))
+#       (end-dst (calendar-gregorian-from-absolute end-dst-absolute))
+#       (next-year-beg-dst (calendar-gregorian-from-absolute
+#                           next-year-beg-dst-absolute))
+#       (year (calendar-extract-year beg-dst))
+#       (range-end (if range-start year "only")))
+#    (setq range-start (or range-start year))
+#    (when (or (/= (calendar-extract-day beg-dst)
+#                  (calendar-extract-day next-year-beg-dst))
+#              (= persian-year last-persian-year))
+#      (insert
+#       (format
+#        "Rule\tIran\t%d\t%s\t-\t%s\t%2d\t24:00\t1:00\t-\n"
+#        range-start range-end
+#        (calendar-month-name (calendar-extract-month beg-dst) t)
+#        (calendar-extract-day beg-dst)))
+#      (insert
+#       (format
+#        "Rule\tIran\t%d\t%s\t-\t%s\t%2d\t24:00\t0\t-\n"
+#        range-start range-end
+#        (calendar-month-name (calendar-extract-month end-dst) t)
+#        (calendar-extract-day end-dst)))
+#      (setq range-start nil))))
+#
+# From Oscar van Vlijmen (2005-03-30), writing about future
+# discrepancies between cal-persia and the Iranian calendar:
+# For 2091 solar-longitude-after yields 2091-03-20 08:40:07.7 UT for
+# the vernal equinox and that gets so close to 12:00 some local
+# Iranian time that the definition of the correct location needs to be
+# known exactly, amongst other factors.  2157 is even closer:
+# 2157-03-20 08:37:15.5 UT.  But the Gregorian year 2025 should give
+# no interpretation problem whatsoever.  By the way, another instant
+# in the near future where there will be a discrepancy between
+# arithmetical and astronomical Iranian calendars will be in 2058:
+# vernal equinox on 2058-03-20 09:03:05.9 UT.  The Java version of
+# Reingold's/Dershowitz' calculator gives correctly the Gregorian date
+# 2058-03-21 for 1 Farvardin 1437 (astronomical).
+#
+# From Steffen Thorsen (2006-03-22):
+# Several of my users have reported that Iran will not observe DST anymore:
+# http://www.irna.ir/en/news/view/line-17/0603193812164948.htm
+#
+# From Reuters (2007-09-16), with a heads-up from Jesper Nørgaard Welen:
+# ... the Guardian Council ... approved a law on Sunday to re-introduce
+# daylight saving time ...
+# https://uk.reuters.com/article/oilRpt/idUKBLA65048420070916
+#
+# From Roozbeh Pournader (2007-11-05):
+# This is quoted from Official Gazette of the Islamic Republic of
+# Iran, Volume 63, No. 18242, dated Tuesday 1386/6/24
+# [2007-10-16]. I am doing the best translation I can:...
+# The official time of the country will be moved forward for one hour
+# on the 24 hours of the first day of the month of Farvardin and will
+# be changed back to its previous state on the 24 hours of the
+# thirtieth day of Shahrivar.
+#
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Iran	1978	1980	-	Mar	20	24:00	1:00	-
+Rule	Iran	1978	only	-	Oct	20	24:00	0	-
+Rule	Iran	1979	only	-	Sep	18	24:00	0	-
+Rule	Iran	1980	only	-	Sep	22	24:00	0	-
+Rule	Iran	1991	only	-	May	 2	24:00	1:00	-
+Rule	Iran	1992	1995	-	Mar	21	24:00	1:00	-
+Rule	Iran	1991	1995	-	Sep	21	24:00	0	-
+Rule	Iran	1996	only	-	Mar	20	24:00	1:00	-
+Rule	Iran	1996	only	-	Sep	20	24:00	0	-
+Rule	Iran	1997	1999	-	Mar	21	24:00	1:00	-
+Rule	Iran	1997	1999	-	Sep	21	24:00	0	-
+Rule	Iran	2000	only	-	Mar	20	24:00	1:00	-
+Rule	Iran	2000	only	-	Sep	20	24:00	0	-
+Rule	Iran	2001	2003	-	Mar	21	24:00	1:00	-
+Rule	Iran	2001	2003	-	Sep	21	24:00	0	-
+Rule	Iran	2004	only	-	Mar	20	24:00	1:00	-
+Rule	Iran	2004	only	-	Sep	20	24:00	0	-
+Rule	Iran	2005	only	-	Mar	21	24:00	1:00	-
+Rule	Iran	2005	only	-	Sep	21	24:00	0	-
+Rule	Iran	2008	only	-	Mar	20	24:00	1:00	-
+Rule	Iran	2008	only	-	Sep	20	24:00	0	-
+Rule	Iran	2009	2011	-	Mar	21	24:00	1:00	-
+Rule	Iran	2009	2011	-	Sep	21	24:00	0	-
+Rule	Iran	2012	only	-	Mar	20	24:00	1:00	-
+Rule	Iran	2012	only	-	Sep	20	24:00	0	-
+Rule	Iran	2013	2015	-	Mar	21	24:00	1:00	-
+Rule	Iran	2013	2015	-	Sep	21	24:00	0	-
+Rule	Iran	2016	only	-	Mar	20	24:00	1:00	-
+Rule	Iran	2016	only	-	Sep	20	24:00	0	-
+Rule	Iran	2017	2019	-	Mar	21	24:00	1:00	-
+Rule	Iran	2017	2019	-	Sep	21	24:00	0	-
+Rule	Iran	2020	only	-	Mar	20	24:00	1:00	-
+Rule	Iran	2020	only	-	Sep	20	24:00	0	-
+Rule	Iran	2021	2023	-	Mar	21	24:00	1:00	-
+Rule	Iran	2021	2023	-	Sep	21	24:00	0	-
+Rule	Iran	2024	only	-	Mar	20	24:00	1:00	-
+Rule	Iran	2024	only	-	Sep	20	24:00	0	-
+Rule	Iran	2025	2027	-	Mar	21	24:00	1:00	-
+Rule	Iran	2025	2027	-	Sep	21	24:00	0	-
+Rule	Iran	2028	2029	-	Mar	20	24:00	1:00	-
+Rule	Iran	2028	2029	-	Sep	20	24:00	0	-
+Rule	Iran	2030	2031	-	Mar	21	24:00	1:00	-
+Rule	Iran	2030	2031	-	Sep	21	24:00	0	-
+Rule	Iran	2032	2033	-	Mar	20	24:00	1:00	-
+Rule	Iran	2032	2033	-	Sep	20	24:00	0	-
+Rule	Iran	2034	2035	-	Mar	21	24:00	1:00	-
+Rule	Iran	2034	2035	-	Sep	21	24:00	0	-
+Rule	Iran	2036	2037	-	Mar	20	24:00	1:00	-
+Rule	Iran	2036	2037	-	Sep	20	24:00	0	-
+Rule	Iran	2038	2039	-	Mar	21	24:00	1:00	-
+Rule	Iran	2038	2039	-	Sep	21	24:00	0	-
+Rule	Iran	2040	2041	-	Mar	20	24:00	1:00	-
+Rule	Iran	2040	2041	-	Sep	20	24:00	0	-
+Rule	Iran	2042	2043	-	Mar	21	24:00	1:00	-
+Rule	Iran	2042	2043	-	Sep	21	24:00	0	-
+Rule	Iran	2044	2045	-	Mar	20	24:00	1:00	-
+Rule	Iran	2044	2045	-	Sep	20	24:00	0	-
+Rule	Iran	2046	2047	-	Mar	21	24:00	1:00	-
+Rule	Iran	2046	2047	-	Sep	21	24:00	0	-
+Rule	Iran	2048	2049	-	Mar	20	24:00	1:00	-
+Rule	Iran	2048	2049	-	Sep	20	24:00	0	-
+Rule	Iran	2050	2051	-	Mar	21	24:00	1:00	-
+Rule	Iran	2050	2051	-	Sep	21	24:00	0	-
+Rule	Iran	2052	2053	-	Mar	20	24:00	1:00	-
+Rule	Iran	2052	2053	-	Sep	20	24:00	0	-
+Rule	Iran	2054	2055	-	Mar	21	24:00	1:00	-
+Rule	Iran	2054	2055	-	Sep	21	24:00	0	-
+Rule	Iran	2056	2057	-	Mar	20	24:00	1:00	-
+Rule	Iran	2056	2057	-	Sep	20	24:00	0	-
+Rule	Iran	2058	2059	-	Mar	21	24:00	1:00	-
+Rule	Iran	2058	2059	-	Sep	21	24:00	0	-
+Rule	Iran	2060	2062	-	Mar	20	24:00	1:00	-
+Rule	Iran	2060	2062	-	Sep	20	24:00	0	-
+Rule	Iran	2063	only	-	Mar	21	24:00	1:00	-
+Rule	Iran	2063	only	-	Sep	21	24:00	0	-
+Rule	Iran	2064	2066	-	Mar	20	24:00	1:00	-
+Rule	Iran	2064	2066	-	Sep	20	24:00	0	-
+Rule	Iran	2067	only	-	Mar	21	24:00	1:00	-
+Rule	Iran	2067	only	-	Sep	21	24:00	0	-
+Rule	Iran	2068	2070	-	Mar	20	24:00	1:00	-
+Rule	Iran	2068	2070	-	Sep	20	24:00	0	-
+Rule	Iran	2071	only	-	Mar	21	24:00	1:00	-
+Rule	Iran	2071	only	-	Sep	21	24:00	0	-
+Rule	Iran	2072	2074	-	Mar	20	24:00	1:00	-
+Rule	Iran	2072	2074	-	Sep	20	24:00	0	-
+Rule	Iran	2075	only	-	Mar	21	24:00	1:00	-
+Rule	Iran	2075	only	-	Sep	21	24:00	0	-
+Rule	Iran	2076	2078	-	Mar	20	24:00	1:00	-
+Rule	Iran	2076	2078	-	Sep	20	24:00	0	-
+Rule	Iran	2079	only	-	Mar	21	24:00	1:00	-
+Rule	Iran	2079	only	-	Sep	21	24:00	0	-
+Rule	Iran	2080	2082	-	Mar	20	24:00	1:00	-
+Rule	Iran	2080	2082	-	Sep	20	24:00	0	-
+Rule	Iran	2083	only	-	Mar	21	24:00	1:00	-
+Rule	Iran	2083	only	-	Sep	21	24:00	0	-
+Rule	Iran	2084	2086	-	Mar	20	24:00	1:00	-
+Rule	Iran	2084	2086	-	Sep	20	24:00	0	-
+Rule	Iran	2087	only	-	Mar	21	24:00	1:00	-
+Rule	Iran	2087	only	-	Sep	21	24:00	0	-
+#
+# The following rules are approximations starting in the year 2088.
+# These are the best post-2088 approximations available, given the
+# restrictions of a single rule using ordinary Gregorian dates.
+# At some point this table will need to be extended, though quite
+# possibly Iran will change the rules first.
+Rule	Iran	2088	max	-	Mar	20	24:00	1:00	-
+Rule	Iran	2088	max	-	Sep	20	24:00	0	-
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Tehran	3:25:44	-	LMT	1916
+			3:25:44	-	TMT	1946     # Tehran Mean Time
+			3:30	-	+0330	1977 Nov
+			4:00	Iran	+04/+05	1979
+			3:30	Iran	+0330/+0430
+
+
+# Iraq
+#
+# From Jonathan Lennox (2000-06-12):
+# An article in this week's Economist ("Inside the Saddam-free zone", p. 50 in
+# the U.S. edition) on the Iraqi Kurds contains a paragraph:
+# "The three northern provinces ... switched their clocks this spring and
+# are an hour ahead of Baghdad."
+#
+# But Rives McDow (2000-06-18) quotes a contact in Iraqi-Kurdistan as follows:
+# In the past, some Kurdish nationalists, as a protest to the Iraqi
+# Government, did not adhere to daylight saving time.  They referred
+# to daylight saving as Saddam time.  But, as of today, the time zone
+# in Iraqi-Kurdistan is on standard time with Baghdad, Iraq.
+#
+# So we'll ignore the Economist's claim.
+
+# From Steffen Thorsen (2008-03-10):
+# The cabinet in Iraq abolished DST last week, according to the following
+# news sources (in Arabic):
+# http://www.aljeeran.net/wesima_articles/news-20080305-98602.html
+# http://www.aswataliraq.info/look/article.tpl?id=2047&IdLanguage=17&IdPublication=4&NrArticle=71743&NrIssue=1&NrSection=10
+#
+# We have published a short article in English about the change:
+# https://www.timeanddate.com/news/time/iraq-dumps-daylight-saving.html
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Iraq	1982	only	-	May	1	0:00	1:00	-
+Rule	Iraq	1982	1984	-	Oct	1	0:00	0	-
+Rule	Iraq	1983	only	-	Mar	31	0:00	1:00	-
+Rule	Iraq	1984	1985	-	Apr	1	0:00	1:00	-
+Rule	Iraq	1985	1990	-	Sep	lastSun	1:00s	0	-
+Rule	Iraq	1986	1990	-	Mar	lastSun	1:00s	1:00	-
+# IATA SSIM (1991/1996) says Apr 1 12:01am UTC; guess the ':01' is a typo.
+# Shanks & Pottenger say Iraq did not observe DST 1992/1997; ignore this.
+#
+Rule	Iraq	1991	2007	-	Apr	 1	3:00s	1:00	-
+Rule	Iraq	1991	2007	-	Oct	 1	3:00s	0	-
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Baghdad	2:57:40	-	LMT	1890
+			2:57:36	-	BMT	1918     # Baghdad Mean Time?
+			3:00	-	+03	1982 May
+			3:00	Iraq	+03/+04
+
+
+###############################################################################
+
+# Israel
+
+# From Ephraim Silverberg (2001-01-11):
+#
+# I coined "IST/IDT" circa 1988.  Until then there were three
+# different abbreviations in use:
+#
+# JST  Jerusalem Standard Time [Danny Braniss, Hebrew University]
+# IZT  Israel Zonal (sic) Time [Prof. Haim Papo, Technion]
+# EEST Eastern Europe Standard Time [used by almost everyone else]
+#
+# Since timezones should be called by country and not capital cities,
+# I ruled out JST.  As Israel is in Asia Minor and not Eastern Europe,
+# EEST was equally unacceptable.  Since "zonal" was not compatible with
+# any other timezone abbreviation, I felt that 'IST' was the way to go
+# and, indeed, it has received almost universal acceptance in timezone
+# settings in Israeli computers.
+#
+# In any case, I am happy to share timezone abbreviations with India,
+# high on my favorite-country list (and not only because my wife's
+# family is from India).
+
+# From Shanks & Pottenger:
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Zion	1940	only	-	Jun	 1	0:00	1:00	D
+Rule	Zion	1942	1944	-	Nov	 1	0:00	0	S
+Rule	Zion	1943	only	-	Apr	 1	2:00	1:00	D
+Rule	Zion	1944	only	-	Apr	 1	0:00	1:00	D
+Rule	Zion	1945	only	-	Apr	16	0:00	1:00	D
+Rule	Zion	1945	only	-	Nov	 1	2:00	0	S
+Rule	Zion	1946	only	-	Apr	16	2:00	1:00	D
+Rule	Zion	1946	only	-	Nov	 1	0:00	0	S
+Rule	Zion	1948	only	-	May	23	0:00	2:00	DD
+Rule	Zion	1948	only	-	Sep	 1	0:00	1:00	D
+Rule	Zion	1948	1949	-	Nov	 1	2:00	0	S
+Rule	Zion	1949	only	-	May	 1	0:00	1:00	D
+Rule	Zion	1950	only	-	Apr	16	0:00	1:00	D
+Rule	Zion	1950	only	-	Sep	15	3:00	0	S
+Rule	Zion	1951	only	-	Apr	 1	0:00	1:00	D
+Rule	Zion	1951	only	-	Nov	11	3:00	0	S
+Rule	Zion	1952	only	-	Apr	20	2:00	1:00	D
+Rule	Zion	1952	only	-	Oct	19	3:00	0	S
+Rule	Zion	1953	only	-	Apr	12	2:00	1:00	D
+Rule	Zion	1953	only	-	Sep	13	3:00	0	S
+Rule	Zion	1954	only	-	Jun	13	0:00	1:00	D
+Rule	Zion	1954	only	-	Sep	12	0:00	0	S
+Rule	Zion	1955	only	-	Jun	11	2:00	1:00	D
+Rule	Zion	1955	only	-	Sep	11	0:00	0	S
+Rule	Zion	1956	only	-	Jun	 3	0:00	1:00	D
+Rule	Zion	1956	only	-	Sep	30	3:00	0	S
+Rule	Zion	1957	only	-	Apr	29	2:00	1:00	D
+Rule	Zion	1957	only	-	Sep	22	0:00	0	S
+Rule	Zion	1974	only	-	Jul	 7	0:00	1:00	D
+Rule	Zion	1974	only	-	Oct	13	0:00	0	S
+Rule	Zion	1975	only	-	Apr	20	0:00	1:00	D
+Rule	Zion	1975	only	-	Aug	31	0:00	0	S
+
+# From Alois Treindl (2019-03-06):
+# http://www.moin.gov.il/Documents/שעון%20קיץ/clock-50-years-7-2014.pdf
+# From Isaac Starkman (2019-03-06):
+# Summer time was in that period in 1980 and 1984, see
+# https://www.ynet.co.il/articles/0,7340,L-3951073,00.html
+# You can of course read it in translation.
+# I checked the local newspapers for that years.
+# It started on midnight and end at 01.00 am.
+# From Paul Eggert (2019-03-06):
+# Also see this thread about the moin.gov.il URL:
+# https://mm.icann.org/pipermail/tz/2018-November/027194.html
+Rule	Zion	1980	only	-	Aug	 2	0:00	1:00	D
+Rule	Zion	1980	only	-	Sep	13	1:00	0	S
+Rule	Zion	1984	only	-	May	 5	0:00	1:00	D
+Rule	Zion	1984	only	-	Aug	25	1:00	0	S
+
+# From Shanks & Pottenger:
+Rule	Zion	1985	only	-	Apr	14	0:00	1:00	D
+Rule	Zion	1985	only	-	Sep	15	0:00	0	S
+Rule	Zion	1986	only	-	May	18	0:00	1:00	D
+Rule	Zion	1986	only	-	Sep	 7	0:00	0	S
+Rule	Zion	1987	only	-	Apr	15	0:00	1:00	D
+Rule	Zion	1987	only	-	Sep	13	0:00	0	S
+
+# From Avigdor Finkelstein (2014-03-05):
+# I check the Parliament (Knesset) records and there it's stated that the
+# [1988] transition should take place on Saturday night, when the Sabbath
+# ends and changes to Sunday.
+Rule	Zion	1988	only	-	Apr	10	0:00	1:00	D
+Rule	Zion	1988	only	-	Sep	 4	0:00	0	S
+
+# From Ephraim Silverberg
+# (1997-03-04, 1998-03-16, 1998-12-28, 2000-01-17, 2000-07-25, 2004-12-22,
+# and 2005-02-17):
+
+# According to the Office of the Secretary General of the Ministry of
+# Interior, there is NO set rule for Daylight-Savings/Standard time changes.
+# One thing is entrenched in law, however: that there must be at least 150
+# days of daylight savings time annually.  From 1993-1998, the change to
+# daylight savings time was on a Friday morning from midnight IST to
+# 1 a.m IDT; up until 1998, the change back to standard time was on a
+# Saturday night from midnight daylight savings time to 11 p.m. standard
+# time.  1996 is an exception to this rule where the change back to standard
+# time took place on Sunday night instead of Saturday night to avoid
+# conflicts with the Jewish New Year.  In 1999, the change to
+# daylight savings time was still on a Friday morning but from
+# 2 a.m. IST to 3 a.m. IDT; furthermore, the change back to standard time
+# was also on a Friday morning from 2 a.m. IDT to 1 a.m. IST for
+# 1999 only.  In the year 2000, the change to daylight savings time was
+# similar to 1999, but although the change back will be on a Friday, it
+# will take place from 1 a.m. IDT to midnight IST.  Starting in 2001, all
+# changes to/from will take place at 1 a.m. old time, but now there is no
+# rule as to what day of the week it will take place in as the start date
+# (except in 2003) is the night after the Passover Seder (i.e. the eve
+# of the 16th of Nisan in the lunar Hebrew calendar) and the end date
+# (except in 2002) is three nights before Yom Kippur [Day of Atonement]
+# (the eve of the 7th of Tishrei in the lunar Hebrew calendar).
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Zion	1989	only	-	Apr	30	0:00	1:00	D
+Rule	Zion	1989	only	-	Sep	 3	0:00	0	S
+Rule	Zion	1990	only	-	Mar	25	0:00	1:00	D
+Rule	Zion	1990	only	-	Aug	26	0:00	0	S
+Rule	Zion	1991	only	-	Mar	24	0:00	1:00	D
+Rule	Zion	1991	only	-	Sep	 1	0:00	0	S
+Rule	Zion	1992	only	-	Mar	29	0:00	1:00	D
+Rule	Zion	1992	only	-	Sep	 6	0:00	0	S
+Rule	Zion	1993	only	-	Apr	 2	0:00	1:00	D
+Rule	Zion	1993	only	-	Sep	 5	0:00	0	S
+
+# The dates for 1994-1995 were obtained from Office of the Spokeswoman for the
+# Ministry of Interior, Jerusalem, Israel.  The spokeswoman can be reached by
+# calling the office directly at 972-2-6701447 or 972-2-6701448.
+
+# Rule	NAME    FROM    TO      TYPE    IN      ON      AT      SAVE    LETTER/S
+Rule	Zion	1994	only	-	Apr	 1	0:00	1:00	D
+Rule	Zion	1994	only	-	Aug	28	0:00	0	S
+Rule	Zion	1995	only	-	Mar	31	0:00	1:00	D
+Rule	Zion	1995	only	-	Sep	 3	0:00	0	S
+
+# The dates for 1996 were determined by the Minister of Interior of the
+# time, Haim Ramon.  The official announcement regarding 1996-1998
+# (with the dates for 1997-1998 no longer being relevant) can be viewed at:
+#
+#   ftp://ftp.cs.huji.ac.il/pub/tz/announcements/1996-1998.ramon.ps.gz
+#
+# The dates for 1997-1998 were altered by his successor, Rabbi Eli Suissa.
+#
+# The official announcements for the years 1997-1999 can be viewed at:
+#
+#   ftp://ftp.cs.huji.ac.il/pub/tz/announcements/YYYY.ps.gz
+#
+#       where YYYY is the relevant year.
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Zion	1996	only	-	Mar	15	0:00	1:00	D
+Rule	Zion	1996	only	-	Sep	16	0:00	0	S
+Rule	Zion	1997	only	-	Mar	21	0:00	1:00	D
+Rule	Zion	1997	only	-	Sep	14	0:00	0	S
+Rule	Zion	1998	only	-	Mar	20	0:00	1:00	D
+Rule	Zion	1998	only	-	Sep	 6	0:00	0	S
+Rule	Zion	1999	only	-	Apr	 2	2:00	1:00	D
+Rule	Zion	1999	only	-	Sep	 3	2:00	0	S
+
+# The Knesset Interior Committee has changed the dates for 2000 for
+# the third time in just over a year and have set new dates for the
+# years 2001-2004 as well.
+#
+# The official announcement for the start date of 2000 can be viewed at:
+#
+#	ftp://ftp.cs.huji.ac.il/pub/tz/announcements/2000-start.ps.gz
+#
+# The official announcement for the end date of 2000 and the dates
+# for the years 2001-2004 can be viewed at:
+#
+#	ftp://ftp.cs.huji.ac.il/pub/tz/announcements/2000-2004.ps.gz
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Zion	2000	only	-	Apr	14	2:00	1:00	D
+Rule	Zion	2000	only	-	Oct	 6	1:00	0	S
+Rule	Zion	2001	only	-	Apr	 9	1:00	1:00	D
+Rule	Zion	2001	only	-	Sep	24	1:00	0	S
+Rule	Zion	2002	only	-	Mar	29	1:00	1:00	D
+Rule	Zion	2002	only	-	Oct	 7	1:00	0	S
+Rule	Zion	2003	only	-	Mar	28	1:00	1:00	D
+Rule	Zion	2003	only	-	Oct	 3	1:00	0	S
+Rule	Zion	2004	only	-	Apr	 7	1:00	1:00	D
+Rule	Zion	2004	only	-	Sep	22	1:00	0	S
+
+# The proposed law agreed upon by the Knesset Interior Committee on
+# 2005-02-14 is that, for 2005 and beyond, DST starts at 02:00 the
+# last Friday before April 2nd (i.e. the last Friday in March or April
+# 1st itself if it falls on a Friday) and ends at 02:00 on the Saturday
+# night _before_ the fast of Yom Kippur.
+#
+# Those who can read Hebrew can view the announcement at:
+#
+#	ftp://ftp.cs.huji.ac.il/pub/tz/announcements/2005+beyond.ps
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Zion	2005	2012	-	Apr	Fri<=1	2:00	1:00	D
+Rule	Zion	2005	only	-	Oct	 9	2:00	0	S
+Rule	Zion	2006	only	-	Oct	 1	2:00	0	S
+Rule	Zion	2007	only	-	Sep	16	2:00	0	S
+Rule	Zion	2008	only	-	Oct	 5	2:00	0	S
+Rule	Zion	2009	only	-	Sep	27	2:00	0	S
+Rule	Zion	2010	only	-	Sep	12	2:00	0	S
+Rule	Zion	2011	only	-	Oct	 2	2:00	0	S
+Rule	Zion	2012	only	-	Sep	23	2:00	0	S
+
+# From Ephraim Silverberg (2013-06-27):
+# On June 23, 2013, the Israeli government approved changes to the
+# Time Decree Law.  The next day, the changes passed the First Reading
+# in the Knesset.  The law is expected to pass the Second and Third
+# (final) Readings by the beginning of September 2013.
+#
+# As of 2013, DST starts at 02:00 on the Friday before the last Sunday
+# in March.  DST ends at 02:00 on the last Sunday of October.
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Zion	2013	max	-	Mar	Fri>=23	2:00	1:00	D
+Rule	Zion	2013	max	-	Oct	lastSun	2:00	0	S
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Jerusalem	2:20:54 -	LMT	1880
+			2:20:40	-	JMT	1918 # Jerusalem Mean Time?
+			2:00	Zion	I%sT
+
+
+
+###############################################################################
+
+# Japan
+
+# '9:00' and 'JST' is from Guy Harris.
+
+# From Paul Eggert (1995-03-06):
+# Today's _Asahi Evening News_ (page 4) reports that Japan had
+# daylight saving between 1948 and 1951, but "the system was discontinued
+# because the public believed it would lead to longer working hours."
+
+# From Mayumi Negishi in the 2005-08-10 Japan Times:
+# http://www.japantimes.co.jp/cgi-bin/getarticle.pl5?nn20050810f2.htm
+# Occupation authorities imposed daylight-saving time on Japan on
+# [1948-05-01]....  But lack of prior debate and the execution of
+# daylight-saving time just three days after the bill was passed generated
+# deep hatred of the concept....  The Diet unceremoniously passed a bill to
+# dump the unpopular system in October 1951, less than a month after the San
+# Francisco Peace Treaty was signed.  (A government poll in 1951 showed 53%
+# of the Japanese wanted to scrap daylight-saving time, as opposed to 30% who
+# wanted to keep it.)
+
+# From Takayuki Nikai (2018-01-19):
+# The source of information is Japanese law.
+# http://www.shugiin.go.jp/internet/itdb_housei.nsf/html/houritsu/00219480428029.htm
+# http://www.shugiin.go.jp/internet/itdb_housei.nsf/html/houritsu/00719500331039.htm
+# ... In summary, it is written as follows.  From 24:00 on the first Saturday
+# in May, until 0:00 on the day after the second Saturday in September.
+
+# From Phake Nick (2018-09-27):
+# [T]he webpage authored by National Astronomical Observatory of Japan
+# https://eco.mtk.nao.ac.jp/koyomi/wiki/BBFEB9EF2FB2C6BBFEB9EF.html
+# ... mentioned that using Showa 23 (year 1948) as example, 13pm of September
+# 11 in summer time will equal to 0am of September 12 in standard time.
+# It cited a document issued by the Liaison Office which briefly existed
+# during the postwar period of Japan, where the detail on implementation
+# of the summer time is described in the document.
+# https://eco.mtk.nao.ac.jp/koyomi/wiki/BBFEB9EF2FB2C6BBFEB9EFB2C6BBFEB9EFA4CEBCC2BBDCA4CBA4C4A4A4A4C6.pdf
+# The text in the document do instruct a fall back to occur at
+# September 11, 13pm in summer time, while ordinary citizens can
+# change the clock before they sleep.
+#
+# From Paul Eggert (2018-09-27):
+# This instruction is equivalent to "Sat>=8 25:00", so use that.  zic treats
+# it like "Sun>=9 01:00", which is not quite the same but is the best we can
+# do in any POSIX or C platform.  The "25:00" assumes zic from 2007 or later,
+# which should be safe now.
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Japan	1948	only	-	May	Sat>=1	24:00	1:00	D
+Rule	Japan	1948	1951	-	Sep	Sat>=8	25:00	0	S
+Rule	Japan	1949	only	-	Apr	Sat>=1	24:00	1:00	D
+Rule	Japan	1950	1951	-	May	Sat>=1	24:00	1:00	D
+
+# From Hideyuki Suzuki (1998-11-09):
+# 'Tokyo' usually stands for the former location of Tokyo Astronomical
+# Observatory: 139° 44' 40.90" E (9h 18m 58.727s), 35° 39' 16.0" N.
+# This data is from 'Rika Nenpyou (Chronological Scientific Tables) 1996'
+# edited by National Astronomical Observatory of Japan....
+# JST (Japan Standard Time) has been used since 1888-01-01 00:00 (JST).
+# The law is enacted on 1886-07-07.
+
+# From Hideyuki Suzuki (1998-11-16):
+# The ordinance No. 51 (1886) established "standard time" in Japan,
+# which stands for the time on 135° E.
+# In the ordinance No. 167 (1895), "standard time" was renamed to "central
+# standard time".  And the same ordinance also established "western standard
+# time", which stands for the time on 120° E....  But "western standard
+# time" was abolished in the ordinance No. 529 (1937).  In the ordinance No.
+# 167, there is no mention regarding for what place western standard time is
+# standard....
+#
+# I wrote "ordinance" above, but I don't know how to translate.
+# In Japanese it's "chokurei", which means ordinance from emperor.
+
+# From Yu-Cheng Chuang (2013-07-12):
+# ...the Meiji Emperor announced Ordinance No. 167 of Meiji Year 28 "The clause
+# about standard time" ... The adoption began from Jan 1, 1896.
+# https://ja.wikisource.org/wiki/標準時ニ關スル件_(公布時)
+#
+# ...the Showa Emperor announced Ordinance No. 529 of Showa Year 12 ... which
+# means the whole Japan territory, including later occupations, adopt Japan
+# Central Time (UT+9). The adoption began on Oct 1, 1937.
+# https://ja.wikisource.org/wiki/明治二十八年勅令第百六十七號標準時ニ關スル件中改正ノ件
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Tokyo	9:18:59	-	LMT	1887 Dec 31 15:00u
+			9:00	Japan	J%sT
+# Since 1938, all Japanese possessions have been like Asia/Tokyo,
+# except that Truk (Chuuk), Ponape (Pohnpei), and Jaluit (Kosrae) did not
+# switch from +10 to +09 until 1941-04-01; see the 'australasia' file.
+
+# Jordan
+#
+# From <http://star.arabia.com/990701/JO9.html>
+# Jordan Week (1999-07-01) via Steffen Thorsen (1999-09-09):
+# Clocks in Jordan were forwarded one hour on Wednesday at midnight,
+# in accordance with the government's decision to implement summer time
+# all year round.
+#
+# From <http://star.arabia.com/990930/JO9.html>
+# Jordan Week (1999-09-30) via Steffen Thorsen (1999-11-09):
+# Winter time starts today Thursday, 30 September. Clocks will be turned back
+# by one hour.  This is the latest government decision and it's final!
+# The decision was taken because of the increase in working hours in
+# government's departments from six to seven hours.
+#
+# From Paul Eggert (2005-11-22):
+# Starting 2003 transitions are from Steffen Thorsen's web site timeanddate.com.
+#
+# From Steffen Thorsen (2005-11-23):
+# For Jordan I have received multiple independent user reports every year
+# about DST end dates, as the end-rule is different every year.
+#
+# From Steffen Thorsen (2006-10-01), after a heads-up from Hilal Malawi:
+# http://www.petranews.gov.jo/nepras/2006/Sep/05/4000.htm
+# "Jordan will switch to winter time on Friday, October 27".
+#
+
+# From Steffen Thorsen (2009-04-02):
+# This single one might be good enough, (2009-03-24, Arabic):
+# http://petra.gov.jo/Artical.aspx?Lng=2&Section=8&Artical=95279
+#
+# Google's translation:
+#
+# > The Council of Ministers decided in 2002 to adopt the principle of timely
+# > submission of the summer at 60 minutes as of midnight on the last Thursday
+# > of the month of March of each year.
+#
+# So - this means the midnight between Thursday and Friday since 2002.
+
+# From Arthur David Olson (2009-04-06):
+# We still have Jordan switching to DST on Thursdays in 2000 and 2001.
+
+# From Steffen Thorsen (2012-10-25):
+# Yesterday the government in Jordan announced that they will not
+# switch back to standard time this winter, so the will stay on DST
+# until about the same time next year (at least).
+# http://www.petra.gov.jo/Public_News/Nws_NewsDetails.aspx?NewsID=88950
+
+# From Steffen Thorsen (2013-12-11):
+# Jordan Times and other sources say that Jordan is going back to
+# UTC+2 on 2013-12-19 at midnight:
+# http://jordantimes.com/govt-decides-to-switch-back-to-wintertime
+# Official, in Arabic:
+# http://www.petra.gov.jo/public_news/Nws_NewsDetails.aspx?Menu_ID=&Site_Id=2&lang=1&NewsID=133230&CatID=14
+# ... Our background/permalink about it
+# https://www.timeanddate.com/news/time/jordan-reverses-dst-decision.html
+# ...
+# http://www.petra.gov.jo/Public_News/Nws_NewsDetails.aspx?lang=2&site_id=1&NewsID=133313&Type=P
+# ... says midnight for the coming one and 1:00 for the ones in the future
+# (and they will use DST again next year, using the normal schedule).
+
+# From Paul Eggert (2013-12-11):
+# As Steffen suggested, consider the past 21-month experiment to be DST.
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Jordan	1973	only	-	Jun	6	0:00	1:00	S
+Rule	Jordan	1973	1975	-	Oct	1	0:00	0	-
+Rule	Jordan	1974	1977	-	May	1	0:00	1:00	S
+Rule	Jordan	1976	only	-	Nov	1	0:00	0	-
+Rule	Jordan	1977	only	-	Oct	1	0:00	0	-
+Rule	Jordan	1978	only	-	Apr	30	0:00	1:00	S
+Rule	Jordan	1978	only	-	Sep	30	0:00	0	-
+Rule	Jordan	1985	only	-	Apr	1	0:00	1:00	S
+Rule	Jordan	1985	only	-	Oct	1	0:00	0	-
+Rule	Jordan	1986	1988	-	Apr	Fri>=1	0:00	1:00	S
+Rule	Jordan	1986	1990	-	Oct	Fri>=1	0:00	0	-
+Rule	Jordan	1989	only	-	May	8	0:00	1:00	S
+Rule	Jordan	1990	only	-	Apr	27	0:00	1:00	S
+Rule	Jordan	1991	only	-	Apr	17	0:00	1:00	S
+Rule	Jordan	1991	only	-	Sep	27	0:00	0	-
+Rule	Jordan	1992	only	-	Apr	10	0:00	1:00	S
+Rule	Jordan	1992	1993	-	Oct	Fri>=1	0:00	0	-
+Rule	Jordan	1993	1998	-	Apr	Fri>=1	0:00	1:00	S
+Rule	Jordan	1994	only	-	Sep	Fri>=15	0:00	0	-
+Rule	Jordan	1995	1998	-	Sep	Fri>=15	0:00s	0	-
+Rule	Jordan	1999	only	-	Jul	 1	0:00s	1:00	S
+Rule	Jordan	1999	2002	-	Sep	lastFri	0:00s	0	-
+Rule	Jordan	2000	2001	-	Mar	lastThu	0:00s	1:00	S
+Rule	Jordan	2002	2012	-	Mar	lastThu	24:00	1:00	S
+Rule	Jordan	2003	only	-	Oct	24	0:00s	0	-
+Rule	Jordan	2004	only	-	Oct	15	0:00s	0	-
+Rule	Jordan	2005	only	-	Sep	lastFri	0:00s	0	-
+Rule	Jordan	2006	2011	-	Oct	lastFri	0:00s	0	-
+Rule	Jordan	2013	only	-	Dec	20	0:00	0	-
+Rule	Jordan	2014	max	-	Mar	lastThu	24:00	1:00	S
+Rule	Jordan	2014	max	-	Oct	lastFri	0:00s	0	-
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Amman	2:23:44 -	LMT	1931
+			2:00	Jordan	EE%sT
+
+
+# Kazakhstan
+
+# From Kazakhstan Embassy's News Bulletin No. 11
+# <http://www.kazsociety.org.uk/news/2005/03/30.htm> (2005-03-21):
+# The Government of Kazakhstan passed a resolution March 15 abolishing
+# daylight saving time citing lack of economic benefits and health
+# complications coupled with a decrease in productivity.
+#
+# From Branislav Kojic (in Astana) via Gwillim Law (2005-06-28):
+# ... what happened was that the former Kazakhstan Eastern time zone
+# was "blended" with the Central zone.  Therefore, Kazakhstan now has
+# two time zones, and difference between them is one hour.  The zone
+# closer to UTC is the former Western zone (probably still called the
+# same), encompassing four provinces in the west: Aqtöbe, Atyraū,
+# Mangghystaū, and West Kazakhstan.  The other zone encompasses
+# everything else....  I guess that would make Kazakhstan time zones
+# de jure UTC+5 and UTC+6 respectively.
+
+# From Stepan Golosunov (2016-03-27):
+# Review of the linked documents from http://adilet.zan.kz/
+# produced the following data for post-1991 Kazakhstan:
+#
+# 0. Act of the Cabinet of Ministers of the USSR
+# from 1991-02-04 No. 20
+# http://pravo.gov.ru/proxy/ips/?docbody=&nd=102010545
+# removed the extra hour ("decree time") on the territory of the USSR
+# starting with the last Sunday of March 1991.
+# It also allowed (but not mandated) Kazakh SSR, Kirghiz SSR, Tajik SSR,
+# Turkmen SSR and Uzbek SSR to not have "summer" time.
+#
+# The 1992-01-13 act also refers to the act of the Cabinet of Ministers
+# of the Kazakh SSR from 1991-03-20 No. 170 "About the act of the Cabinet
+# of Ministers of the USSR from 1991-02-04 No. 20" but I didn't found its
+# text.
+#
+# According to Izvestia newspaper No. 68 (23334) from 1991-03-20
+# -- page 6; available at http://libinfo.org/newsr/newsr2574.djvu via
+# http://libinfo.org/index.php?id=58564 -- on 1991-03-31 at 2:00 during
+# transition to "summer" time:
+# Republic of Georgia, Latvian SSR, Lithuanian SSR, SSR Moldova,
+# Estonian SSR; Komi ASSR; Kaliningrad oblast; Nenets autonomous okrug
+# were to move clocks 1 hour forward.
+# Kazakh SSR (excluding Uralsk oblast); Republic of Kyrgyzstan, Tajik
+# SSR; Andijan, Jizzakh, Namangan, Sirdarya, Tashkent, Fergana oblasts
+# of the Uzbek SSR were to move clocks 1 hour backwards.
+# Other territories were to not move clocks.
+# When the "summer" time would end on 1991-09-29, clocks were to be
+# moved 1 hour backwards on the territory of the USSR excluding
+# Kazakhstan, Kirghizia, Uzbekistan, Turkmenia, Tajikistan.
+#
+# Apparently there were last minute changes. Apparently Kazakh act No. 170
+# was one of such changes.
+#
+# https://ru.wikipedia.org/wiki/Декретное_время
+# claims that Sovetskaya Rossiya newspaper on 1991-03-29 published that
+# Nenets autonomous okrug, Komi and Kazakhstan (excluding Uralsk oblast)
+# were to not move clocks and Uralsk oblast was to move clocks
+# forward; on 1991-09-29 Kazakhstan was to move clocks backwards.
+# (Probably there were changes even after that publication. There is an
+# article claiming that Kaliningrad oblast decided on 1991-03-29 to not
+# move clocks.)
+#
+# This implies that on 1991-03-31 Asia/Oral remained on +04/+05 while
+# the rest of Kazakhstan switched from +06/+07 to +05/06 or from +05/06
+# to +04/+05. It's unclear how Qyzylorda oblast moved into the fifth
+# time belt. (By switching from +04/+05 to +05/+06 on 1991-09-29?) ...
+#
+# 1. Act of the Cabinet of Ministers of the Republic of Kazakhstan
+# from 1992-01-13 No. 28
+# http://adilet.zan.kz/rus/docs/P920000028_
+# (text includes modification from the 1996 act)
+# introduced new rules for calculation of time, mirroring Russian
+# 1992-01-08 act.  It specified that time would be calculated
+# according to time belts plus extra hour ("decree time"), moved clocks
+# on the whole territory of Kazakhstan 1 hour forward on 1992-01-19 at
+# 2:00, specified DST rules.  It acknowledged that Kazakhstan was
+# located in the fourth and the fifth time belts and specified the
+# border between them to be located east of Qostanay and Aktyubinsk
+# oblasts (notably including Turgai and Qyzylorda oblasts into the fifth
+# time belt).
+#
+# This means switch on 1992-01-19 at 2:00 from +04/+05 to +05/+06 for
+# Asia/Aqtau, Asia/Aqtobe, Asia/Oral, Atyraū and Qostanay oblasts; from
+# +05/+06 to +06/+07 for Asia/Almaty and Asia/Qyzylorda (and Arkalyk)....
+#
+# 2. Act of the Cabinet of Ministers of the Republic of Kazakhstan
+# from 1992-03-27 No. 284
+# http://adilet.zan.kz/rus/docs/P920000284_
+# cancels extra hour ("decree time") for Uralsk and Qyzylorda oblasts
+# since the last Sunday of March 1992, while keeping them in the fourth
+# and the fifth time belts respectively.
+#
+# 3. Order of the Prime Minister of the Republic of Kazakhstan
+# from 1994-09-23 No. 384
+# http://adilet.zan.kz/rus/docs/R940000384_
+# cancels the extra hour ("decree time") on the territory of Mangghystaū
+# oblast since the last Sunday of September 1994 (saying that time on
+# the territory would correspond to the third time belt as a
+# result)....
+#
+# 4. Act of the Government of the Republic of Kazakhstan
+# from 1996-05-08 No. 575
+# http://adilet.zan.kz/rus/docs/P960000575_
+# amends the 1992-01-13 act to end summer time in October instead
+# of September, mirroring identical Russian change from 1996-04-23 act.
+#
+# 5. Act of the Government of the Republic of Kazakhstan
+# from 1999-03-26 No. 305
+# http://adilet.zan.kz/rus/docs/P990000305_
+# cancels the extra hour ("decree time") for Atyraū oblast since the
+# last Sunday of March 1999 while retaining the oblast in the fourth
+# time belt.
+#
+# This means change from +05/+06 to +04/+05....
+#
+# 6. Act of the Government of the Republic of Kazakhstan
+# from 2000-11-23 No. 1749
+# http://adilet.zan.kz/rus/archive/docs/P000001749_/23.11.2000
+# replaces the previous five documents.
+#
+# The only changes I noticed are in definition of the border between the
+# fourth and the fifth time belts.  They account for changes in spelling
+# and administrative division (splitting of Turgai oblast in 1997
+# probably changed time in territories incorporated into Qostanay oblast
+# (including Arkalyk) from +06/+07 to +05/+06) and move Qyzylorda oblast
+# from being in the fifth time belt and not using decree time into the
+# fourth time belt (no change in practice).
+#
+# 7. Act of the Government of the Republic of Kazakhstan
+# from 2003-12-29 No. 1342
+# http://adilet.zan.kz/rus/docs/P030001342_
+# modified the 2000-11-23 act.  No relevant changes, apparently.
+#
+# 8. Act of the Government of the Republic of Kazakhstan
+# from 2004-07-20 No. 775
+# http://adilet.zan.kz/rus/archive/docs/P040000775_/20.07.2004
+# modified the 2000-11-23 act to move Qostanay and Qyzylorda oblasts into
+# the fifth time belt and add Aktobe oblast to the list of regions not
+# using extra hour ("decree time"), leaving Kazakhstan with only 2 time
+# zones (+04/+05 and +06/+07).  The changes were to be implemented
+# during DST transitions in 2004 and 2005 but the acts got radically
+# amended before implementation happened.
+#
+# 9. Act of the Government of the Republic of Kazakhstan
+# from 2004-09-15 No. 1059
+# http://adilet.zan.kz/rus/docs/P040001059_
+# modified the 2000-11-23 act to remove exceptions from the "decree time"
+# (leaving Kazakhstan in +05/+06 and +06/+07 zones), amended the
+# 2004-07-20 act to implement changes for Atyraū, West Kazakhstan,
+# Qostanay, Qyzylorda and Mangghystaū oblasts by not moving clocks
+# during the 2004 transition to "winter" time.
+#
+# This means transition from +04/+05 to +05/+06 for Atyraū oblast (no
+# zone currently), Asia/Oral, Asia/Aqtau and transition from +05/+06 to
+# +06/+07 for Qostanay oblast (Qostanay and Arkalyk, no zones currently)
+# and Asia/Qyzylorda on 2004-10-31 at 3:00....
+#
+# 10. Act of the Government of the Republic of Kazakhstan
+# from 2005-03-15 No. 231
+# http://adilet.zan.kz/rus/docs/P050000231_
+# removes DST provisions from the 2000-11-23 act, removes most of the
+# (already implemented) provisions from the 2004-07-20 and 2004-09-15
+# acts, comes into effect 10 days after official publication.
+# The only practical effect seems to be the abolition of the summer
+# time.
+#
+# Unamended version of the act of the Government of the Russian Federation
+# No. 23 from 1992-01-08 [See 'europe' file for details].
+# Kazakh 1992-01-13 act appears to provide the same rules and 1992-03-27
+# act was to be enacted on the last Sunday of March 1992.
+
+# From Stepan Golosunov (2016-11-08):
+# Turgai reorganization should affect only southern part of Qostanay
+# oblast.  Which should probably be separated into Asia/Arkalyk zone.
+# (There were also 1970, 1988 and 1990 Turgai oblast reorganizations
+# according to wikipedia.)
+#
+# [For Qostanay] http://www.ng.kz/gazeta/195/hranit/
+# suggests that clocks were to be moved 40 minutes backwards on
+# 1920-01-01 to the fourth time belt.  But I do not understand
+# how that could happen....
+#
+# [For Atyrau and Oral] 1919 decree
+# (http://www.worldtimezone.com/dst_news/dst_news_russia-1919-02-08.html
+# and in Byalokoz) lists Ural river (plus 10 versts on its left bank) in
+# the third time belt (before 1930 this means +03).
+
+# From Alexander Konzurovski (2018-12-20):
+# Qyzyolrda Region (Asia/Qyzylorda) is changing its time zone from
+# UTC+6 to UTC+5 effective December 21st, 2018. The legal document is
+# located here: http://adilet.zan.kz/rus/docs/P1800000817 (russian language).
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+#
+# Almaty (formerly Alma-Ata), representing most locations in Kazakhstan
+# This includes KZ-AKM, KZ-ALA, KZ-ALM, KZ-AST, KZ-BAY, KZ-VOS, KZ-ZHA,
+# KZ-KAR, KZ-SEV, KZ-PAV, and KZ-YUZ.
+Zone	Asia/Almaty	5:07:48 -	LMT	1924 May  2 # or Alma-Ata
+			5:00	-	+05	1930 Jun 21
+			6:00 RussiaAsia +06/+07	1991 Mar 31  2:00s
+			5:00 RussiaAsia	+05/+06	1992 Jan 19  2:00s
+			6:00 RussiaAsia	+06/+07	2004 Oct 31  2:00s
+			6:00	-	+06
+# Qyzylorda (aka Kyzylorda, Kizilorda, Kzyl-Orda, etc.) (KZ-KZY)
+Zone	Asia/Qyzylorda	4:21:52 -	LMT	1924 May  2
+			4:00	-	+04	1930 Jun 21
+			5:00	-	+05	1981 Apr  1
+			5:00	1:00	+06	1981 Oct  1
+			6:00	-	+06	1982 Apr  1
+			5:00 RussiaAsia	+05/+06	1991 Mar 31  2:00s
+			4:00 RussiaAsia	+04/+05	1991 Sep 29  2:00s
+			5:00 RussiaAsia	+05/+06	1992 Jan 19  2:00s
+			6:00 RussiaAsia	+06/+07	1992 Mar 29  2:00s
+			5:00 RussiaAsia	+05/+06	2004 Oct 31  2:00s
+			6:00	-	+06	2018 Dec 21  0:00
+			5:00	-	+05
+#
+# Qostanay (aka Kostanay, Kustanay) (KZ-KUS)
+# The 1991/2 rules are unclear partly because of the 1997 Turgai
+# reorganization.
+Zone	Asia/Qostanay	4:14:28 -	LMT	1924 May  2
+			4:00	-	+04	1930 Jun 21
+			5:00	-	+05	1981 Apr  1
+			5:00	1:00	+06	1981 Oct  1
+			6:00	-	+06	1982 Apr  1
+			5:00 RussiaAsia	+05/+06	1991 Mar 31  2:00s
+			4:00 RussiaAsia	+04/+05	1992 Jan 19  2:00s
+			5:00 RussiaAsia	+05/+06	2004 Oct 31  2:00s
+			6:00	-	+06
+
+# Aqtöbe (aka Aktobe, formerly Aktyubinsk) (KZ-AKT)
+Zone	Asia/Aqtobe	3:48:40	-	LMT	1924 May  2
+			4:00	-	+04	1930 Jun 21
+			5:00	-	+05	1981 Apr  1
+			5:00	1:00	+06	1981 Oct  1
+			6:00	-	+06	1982 Apr  1
+			5:00 RussiaAsia	+05/+06	1991 Mar 31  2:00s
+			4:00 RussiaAsia	+04/+05	1992 Jan 19  2:00s
+			5:00 RussiaAsia	+05/+06	2004 Oct 31  2:00s
+			5:00	-	+05
+# Mangghystaū (KZ-MAN)
+# Aqtau was not founded until 1963, but it represents an inhabited region,
+# so include timestamps before 1963.
+Zone	Asia/Aqtau	3:21:04	-	LMT	1924 May  2
+			4:00	-	+04	1930 Jun 21
+			5:00	-	+05	1981 Oct  1
+			6:00	-	+06	1982 Apr  1
+			5:00 RussiaAsia	+05/+06	1991 Mar 31  2:00s
+			4:00 RussiaAsia	+04/+05	1992 Jan 19  2:00s
+			5:00 RussiaAsia	+05/+06	1994 Sep 25  2:00s
+			4:00 RussiaAsia	+04/+05	2004 Oct 31  2:00s
+			5:00	-	+05
+# Atyraū (KZ-ATY) is like Mangghystaū except it switched from
+# +04/+05 to +05/+06 in spring 1999, not fall 1994.
+Zone	Asia/Atyrau	3:27:44	-	LMT	1924 May  2
+			3:00	-	+03	1930 Jun 21
+			5:00	-	+05	1981 Oct  1
+			6:00	-	+06	1982 Apr  1
+			5:00 RussiaAsia	+05/+06	1991 Mar 31  2:00s
+			4:00 RussiaAsia	+04/+05	1992 Jan 19  2:00s
+			5:00 RussiaAsia	+05/+06	1999 Mar 28  2:00s
+			4:00 RussiaAsia	+04/+05	2004 Oct 31  2:00s
+			5:00	-	+05
+# West Kazakhstan (KZ-ZAP)
+# From Paul Eggert (2016-03-18):
+# The 1989 transition is from USSR act No. 227 (1989-03-14).
+Zone	Asia/Oral	3:25:24	-	LMT	1924 May  2 # or Ural'sk
+			3:00	-	+03	1930 Jun 21
+			5:00	-	+05	1981 Apr  1
+			5:00	1:00	+06	1981 Oct  1
+			6:00	-	+06	1982 Apr  1
+			5:00 RussiaAsia	+05/+06	1989 Mar 26  2:00s
+			4:00 RussiaAsia	+04/+05	1992 Jan 19  2:00s
+			5:00 RussiaAsia	+05/+06	1992 Mar 29  2:00s
+			4:00 RussiaAsia	+04/+05	2004 Oct 31  2:00s
+			5:00	-	+05
+
+# Kyrgyzstan (Kirgizstan)
+# Transitions through 1991 are from Shanks & Pottenger.
+
+# From Paul Eggert (2005-08-15):
+# According to an article dated today in the Kyrgyzstan Development Gateway
+# http://eng.gateway.kg/cgi-bin/page.pl?id=1&story_name=doc9979.shtml
+# Kyrgyzstan is canceling the daylight saving time system.  I take the article
+# to mean that they will leave their clocks at 6 hours ahead of UTC.
+# From Malik Abdugaliev (2005-09-21):
+# Our government cancels daylight saving time 6th of August 2005.
+# From 2005-08-12 our GMT-offset is +6, w/o any daylight saving.
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Kyrgyz	1992	1996	-	Apr	Sun>=7	0:00s	1:00	-
+Rule	Kyrgyz	1992	1996	-	Sep	lastSun	0:00	0	-
+Rule	Kyrgyz	1997	2005	-	Mar	lastSun	2:30	1:00	-
+Rule	Kyrgyz	1997	2004	-	Oct	lastSun	2:30	0	-
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Bishkek	4:58:24 -	LMT	1924 May  2
+			5:00	-	+05	1930 Jun 21
+			6:00 RussiaAsia +06/+07	1991 Mar 31  2:00s
+			5:00 RussiaAsia	+05/+06	1991 Aug 31  2:00
+			5:00	Kyrgyz	+05/+06	2005 Aug 12
+			6:00	-	+06
+
+###############################################################################
+
+# Korea (North and South)
+
+# From Annie I. Bang (2006-07-10):
+# http://www.koreaherald.com/view.php?ud=200607100012
+# Korea ran a daylight saving program from 1949-61 but stopped it
+# during the 1950-53 Korean War.  The system was temporarily enforced
+# between 1987 and 1988 ...
+
+# From Sanghyuk Jung (2014-10-29):
+# https://mm.icann.org/pipermail/tz/2014-October/021830.html
+# According to the Korean Wikipedia
+# https://ko.wikipedia.org/wiki/한국_표준시
+# [oldid=12896437 2014-09-04 08:03 UTC]
+# DST in Republic of Korea was as follows....  And I checked old
+# newspapers in Korean, all articles correspond with data in Wikipedia.
+# For example, the article in 1948 (Korean Language) proved that DST
+# started at June 1 in that year.  For another example, the article in
+# 1988 said that DST started at 2:00 AM in that year.
+
+# From Phake Nick (2018-10-27):
+# 1. According to official announcement from Korean government, the DST end
+# date in South Korea should be
+# 1955-09-08 without specifying time
+# http://theme.archives.go.kr/next/common/viewEbook.do?singleData=N&archiveEventId=0027977557
+# 1956-09-29 without specifying time
+# http://theme.archives.go.kr/next/common/viewEbook.do?singleData=N&archiveEventId=0027978341
+# 1957-09-21 24 o'clock
+# http://theme.archives.go.kr/next/common/viewEbook.do?singleData=N&archiveEventId=0027979690#3
+# 1958-09-20 24 o'clock
+# http://theme.archives.go.kr/next/common/viewEbook.do?singleData=N&archiveEventId=0027981189
+# 1959-09-19 24 o'clock
+# http://theme.archives.go.kr/next/common/viewEbook.do?singleData=N&archiveEventId=0027982974#2
+# 1960-09-17 24 o'clock
+# http://theme.archives.go.kr/next/common/viewEbook.do?singleData=N&archiveEventId=0028044104
+# ...
+# 2.... https://namu.wiki/w/대한민국%20표준시 ... [says]
+# when Korea was using GMT+8:30 as standard time, the international
+# aviation/marine/meteorological industry in the country refused to
+# follow and continued to use GMT+9:00 for interoperability.
+
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	ROK	1948	only	-	Jun	 1	 0:00	1:00	D
+Rule	ROK	1948	only	-	Sep	12	24:00	0	S
+Rule	ROK	1949	only	-	Apr	 3	 0:00	1:00	D
+Rule	ROK	1949	1951	-	Sep	Sat>=7	24:00	0	S
+Rule	ROK	1950	only	-	Apr	 1	 0:00	1:00	D
+Rule	ROK	1951	only	-	May	 6	 0:00	1:00	D
+Rule	ROK	1955	only	-	May	 5	 0:00	1:00	D
+Rule	ROK	1955	only	-	Sep	 8	24:00	0	S
+Rule	ROK	1956	only	-	May	20	 0:00	1:00	D
+Rule	ROK	1956	only	-	Sep	29	24:00	0	S
+Rule	ROK	1957	1960	-	May	Sun>=1	 0:00	1:00	D
+Rule	ROK	1957	1960	-	Sep	Sat>=17	24:00	0	S
+Rule	ROK	1987	1988	-	May	Sun>=8	 2:00	1:00	D
+Rule	ROK	1987	1988	-	Oct	Sun>=8	 3:00	0	S
+
+# From Paul Eggert (2016-08-23):
+# The Korean Wikipedia entry gives the following sources for UT offsets:
+#
+# 1908: Official Journal Article No. 3994 (decree No. 5)
+# 1912: Governor-General of Korea Official Gazette Issue No. 367
+#       (Announcement No. 338)
+# 1954: Presidential Decree No. 876 (1954-03-17)
+# 1961: Law No. 676 (1961-08-07)
+#
+# (Another source "1987: Law No. 3919 (1986-12-31)" was in the 2014-10-30
+# edition of the Korean Wikipedia entry.)
+#
+# I guessed that time zone abbreviations through 1945 followed the same
+# rules as discussed under Taiwan, with nominal switches from JST to KST
+# when the respective cities were taken over by the Allies after WWII.
+#
+# For Pyongyang, guess no changes from World War II until 2015, as we
+# have no information otherwise.
+
+# From Steffen Thorsen (2015-08-07):
+# According to many news sources, North Korea is going to change to
+# the 8:30 time zone on August 15, one example:
+# http://www.bbc.com/news/world-asia-33815049
+#
+# From Paul Eggert (2015-08-15):
+# Bells rang out midnight (00:00) Friday as part of the celebrations.  See:
+# Talmadge E. North Korea celebrates new time zone, 'Pyongyang Time'
+# http://news.yahoo.com/north-korea-celebrates-time-zone-pyongyang-time-164038128.html
+# There is no common English-language abbreviation for this time zone.
+# Use KST, as that's what we already use for 1954-1961 in ROK.
+
+# From Kang Seonghoon (2018-04-29):
+# North Korea will revert its time zone from UTC+8:30 (PYT; Pyongyang
+# Time) back to UTC+9 (KST; Korea Standard Time).
+#
+# From Seo Sanghyeon (2018-04-30):
+# Rodong Sinmun 2018-04-30 announced Pyongyang Time transition plan.
+# https://www.nknews.org/kcna/wp-content/uploads/sites/5/2018/04/rodong-2018-04-30.pdf
+# ... the transition date is 2018-05-05 ...  Citation should be Decree
+# No. 2232 of April 30, 2018, of the Presidium of the Supreme People's
+# Assembly, as published in Rodong Sinmun.
+# From Tim Parenti (2018-04-29):
+# It appears to be the front page story at the top in the right-most column.
+#
+# From Paul Eggert (2018-05-04):
+# The BBC reported that the transition was from 23:30 to 24:00 today.
+# https://www.bbc.com/news/world-asia-44010705
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Seoul	8:27:52	-	LMT	1908 Apr  1
+			8:30	-	KST	1912 Jan  1
+			9:00	-	JST	1945 Sep  8
+			9:00	ROK	K%sT	1954 Mar 21
+			8:30	ROK	K%sT	1961 Aug 10
+			9:00	ROK	K%sT
+Zone	Asia/Pyongyang	8:23:00 -	LMT	1908 Apr  1
+			8:30	-	KST	1912 Jan  1
+			9:00	-	JST	1945 Aug 24
+			9:00	-	KST	2015 Aug 15 00:00
+			8:30	-	KST	2018 May  4 23:30
+			9:00	-	KST
+
+###############################################################################
+
+# Kuwait
+# See Asia/Riyadh.
+
+# Laos
+# See Asia/Bangkok.
+
+
+# Lebanon
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Lebanon	1920	only	-	Mar	28	0:00	1:00	S
+Rule	Lebanon	1920	only	-	Oct	25	0:00	0	-
+Rule	Lebanon	1921	only	-	Apr	3	0:00	1:00	S
+Rule	Lebanon	1921	only	-	Oct	3	0:00	0	-
+Rule	Lebanon	1922	only	-	Mar	26	0:00	1:00	S
+Rule	Lebanon	1922	only	-	Oct	8	0:00	0	-
+Rule	Lebanon	1923	only	-	Apr	22	0:00	1:00	S
+Rule	Lebanon	1923	only	-	Sep	16	0:00	0	-
+Rule	Lebanon	1957	1961	-	May	1	0:00	1:00	S
+Rule	Lebanon	1957	1961	-	Oct	1	0:00	0	-
+Rule	Lebanon	1972	only	-	Jun	22	0:00	1:00	S
+Rule	Lebanon	1972	1977	-	Oct	1	0:00	0	-
+Rule	Lebanon	1973	1977	-	May	1	0:00	1:00	S
+Rule	Lebanon	1978	only	-	Apr	30	0:00	1:00	S
+Rule	Lebanon	1978	only	-	Sep	30	0:00	0	-
+Rule	Lebanon	1984	1987	-	May	1	0:00	1:00	S
+Rule	Lebanon	1984	1991	-	Oct	16	0:00	0	-
+Rule	Lebanon	1988	only	-	Jun	1	0:00	1:00	S
+Rule	Lebanon	1989	only	-	May	10	0:00	1:00	S
+Rule	Lebanon	1990	1992	-	May	1	0:00	1:00	S
+Rule	Lebanon	1992	only	-	Oct	4	0:00	0	-
+Rule	Lebanon	1993	max	-	Mar	lastSun	0:00	1:00	S
+Rule	Lebanon	1993	1998	-	Sep	lastSun	0:00	0	-
+Rule	Lebanon	1999	max	-	Oct	lastSun	0:00	0	-
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Beirut	2:22:00 -	LMT	1880
+			2:00	Lebanon	EE%sT
+
+# Malaysia
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	NBorneo	1935	1941	-	Sep	14	0:00	0:20	-
+Rule	NBorneo	1935	1941	-	Dec	14	0:00	0	-
+#
+# peninsular Malaysia
+# taken from Mok Ly Yng (2003-10-30)
+# http://www.math.nus.edu.sg/aslaksen/teaching/timezone.html
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone Asia/Kuala_Lumpur	6:46:46 -	LMT	1901 Jan  1
+			6:55:25	-	SMT	1905 Jun  1 # Singapore M.T.
+			7:00	-	+07	1933 Jan  1
+			7:00	0:20	+0720	1936 Jan  1
+			7:20	-	+0720	1941 Sep  1
+			7:30	-	+0730	1942 Feb 16
+			9:00	-	+09	1945 Sep 12
+			7:30	-	+0730	1982 Jan  1
+			8:00	-	+08
+# Sabah & Sarawak
+# From Paul Eggert (2014-08-12):
+# The data entries here are mostly from Shanks & Pottenger, but the 1942, 1945
+# and 1982 transition dates are from Mok Ly Yng.
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone Asia/Kuching	7:21:20	-	LMT	1926 Mar
+			7:30	-	+0730	1933
+			8:00 NBorneo  +08/+0820	1942 Feb 16
+			9:00	-	+09	1945 Sep 12
+			8:00	-	+08
+
+# Maldives
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Indian/Maldives	4:54:00 -	LMT	1880 # Malé
+			4:54:00	-	MMT	1960 # Malé Mean Time
+			5:00	-	+05
+
+# Mongolia
+
+# Shanks & Pottenger say that Mongolia has three time zones, but
+# The USNO (1995-12-21) and the CIA map Standard Time Zones of the World
+# (2005-03) both say that it has just one.
+
+# From Oscar van Vlijmen (1999-12-11):
+# General Information Mongolia
+# <http://www.mongoliatourism.gov.mn/general.htm> (1999-09)
+# "Time: Mongolia has two time zones. Three westernmost provinces of
+# Bayan-Ölgii, Uvs, and Hovd are one hour earlier than the capital city, and
+# the rest of the country follows the Ulaanbaatar time, which is UTC/GMT plus
+# eight hours."
+
+# From Rives McDow (1999-12-13):
+# Mongolia discontinued the use of daylight savings time in 1999; 1998
+# being the last year it was implemented.  The dates of implementation I am
+# unsure of, but most probably it was similar to Russia, except for the time
+# of implementation may have been different....
+# Some maps in the past have indicated that there was an additional time
+# zone in the eastern part of Mongolia, including the provinces of Dornod,
+# Sükhbaatar, and possibly Khentii.
+
+# From Paul Eggert (1999-12-15):
+# Naming and spelling is tricky in Mongolia.
+# We'll use Hovd (also spelled Chovd and Khovd) to represent the west zone;
+# the capital of the Hovd province is sometimes called Hovd, sometimes Dund-Us,
+# and sometimes Jirgalanta (with variant spellings), but the name Hovd
+# is good enough for our purposes.
+
+# From Rives McDow (2001-05-13):
+# In addition to Mongolia starting daylight savings as reported earlier
+# (adopted DST on 2001-04-27 02:00 local time, ending 2001-09-28),
+# there are three time zones.
+#
+# Provinces [at 7:00]: Bayan-Ölgii, Uvs, Khovd, Zavkhan, Govi-Altai
+# Provinces [at 8:00]: Khövsgöl, Bulgan, Arkhangai, Khentii, Töv,
+#	Bayankhongor, Övörkhangai, Dundgovi, Dornogovi, Ömnögovi
+# Provinces [at 9:00]: Dornod, Sükhbaatar
+#
+# [The province of Selenge is omitted from the above lists.]
+
+# From Ganbold Ts., Ulaanbaatar (2004-04-17):
+# Daylight saving occurs at 02:00 local time last Saturday of March.
+# It will change back to normal at 02:00 local time last Saturday of
+# September.... As I remember this rule was changed in 2001.
+#
+# From Paul Eggert (2004-04-17):
+# For now, assume Rives McDow's informant got confused about Friday vs
+# Saturday, and that his 2001 dates should have 1 added to them.
+
+# From Paul Eggert (2005-07-26):
+# We have wildly conflicting information about Mongolia's time zones.
+# Bill Bonnet (2005-05-19) reports that the US Embassy in Ulaanbaatar says
+# there is only one time zone and that DST is observed, citing Microsoft
+# Windows XP as the source.  Risto Nykänen (2005-05-16) reports that
+# travelmongolia.org says there are two time zones (UT +07, +08) with no DST.
+# Oscar van Vlijmen (2005-05-20) reports that the Mongolian Embassy in
+# Washington, DC says there are two time zones, with DST observed.
+# He also found
+# http://ubpost.mongolnews.mn/index.php?subaction=showcomments&id=1111634894&archive=&start_from=&ucat=1&
+# which also says that there is DST, and which has a comment by "Toddius"
+# (2005-03-31 06:05 +0700) saying "Mongolia actually has 3.5 time zones.
+# The West (OLGII) is +7 GMT, most of the country is ULAT is +8 GMT
+# and some Eastern provinces are +9 GMT but Sükhbaatar Aimag is SUHK +8.5 GMT.
+# The SUKH timezone is new this year, it is one of the few things the
+# parliament passed during the tumultuous winter session."
+# For now, let's ignore this information, until we have more confirmation.
+
+# From Ganbold Ts. (2007-02-26):
+# Parliament of Mongolia has just changed the daylight-saving rule in February.
+# They decided not to adopt daylight-saving time....
+# http://www.mongolnews.mn/index.php?module=unuudur&sec=view&id=15742
+
+# From Deborah Goldsmith (2008-03-30):
+# We received a bug report claiming that the tz database UTC offset for
+# Asia/Choibalsan (GMT+09:00) is incorrect, and that it should be GMT
+# +08:00 instead. Different sources appear to disagree with the tz
+# database on this, e.g.:
+#
+# https://www.timeanddate.com/worldclock/city.html?n=1026
+# http://www.worldtimeserver.com/current_time_in_MN.aspx
+#
+# both say GMT+08:00.
+
+# From Steffen Thorsen (2008-03-31):
+# eznis airways, which operates several domestic flights, has a flight
+# schedule here:
+# http://www.eznis.com/Container.jsp?id=112
+# (click the English flag for English)
+#
+# There it appears that flights between Choibalsan and Ulaanbaatar arrive
+# about 1:35 - 1:50 hours later in local clock time, no matter the
+# direction, while Ulaanbaatar-Khovd takes 2 hours in the Eastern
+# direction and 3:35 back, which indicates that Ulaanbaatar and Khovd are
+# in different time zones (like we know about), while Choibalsan and
+# Ulaanbaatar are in the same time zone (correction needed).
+
+# From Arthur David Olson (2008-05-19):
+# Assume that Choibalsan is indeed offset by 8:00.
+# XXX--in the absence of better information, assume that transition
+# was at the start of 2008-03-31 (the day of Steffen Thorsen's report);
+# this is almost surely wrong.
+
+# From Ganbold Tsagaankhuu (2015-03-10):
+# It seems like yesterday Mongolian Government meeting has concluded to use
+# daylight saving time in Mongolia....  Starting at 2:00AM of last Saturday of
+# March 2015, daylight saving time starts.  And 00:00AM of last Saturday of
+# September daylight saving time ends.  Source:
+# http://zasag.mn/news/view/8969
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Mongol	1983	1984	-	Apr	1	0:00	1:00	-
+Rule	Mongol	1983	only	-	Oct	1	0:00	0	-
+# Shanks & Pottenger and IATA SSIM say 1990s switches occurred at 00:00,
+# but McDow says the 2001 switches occurred at 02:00.  Also, IATA SSIM
+# (1996-09) says 1996-10-25.  Go with Shanks & Pottenger through 1998.
+#
+# Shanks & Pottenger say that the Sept. 1984 through Sept. 1990 switches
+# in Choibalsan (more precisely, in Dornod and Sükhbaatar) took place
+# at 02:00 standard time, not at 00:00 local time as in the rest of
+# the country.  That would be odd, and possibly is a result of their
+# correction of 02:00 (in the previous edition) not being done correctly
+# in the latest edition; so ignore it for now.
+
+# From Ganbold Tsagaankhuu (2017-02-09):
+# Mongolian Government meeting has concluded today to cancel daylight
+# saving time adoption in Mongolia.  Source: http://zasag.mn/news/view/16192
+
+Rule	Mongol	1985	1998	-	Mar	lastSun	0:00	1:00	-
+Rule	Mongol	1984	1998	-	Sep	lastSun	0:00	0	-
+# IATA SSIM (1999-09) says Mongolia no longer observes DST.
+Rule	Mongol	2001	only	-	Apr	lastSat	2:00	1:00	-
+Rule	Mongol	2001	2006	-	Sep	lastSat	2:00	0	-
+Rule	Mongol	2002	2006	-	Mar	lastSat	2:00	1:00	-
+Rule	Mongol	2015	2016	-	Mar	lastSat	2:00	1:00	-
+Rule	Mongol	2015	2016	-	Sep	lastSat	0:00	0	-
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+# Hovd, a.k.a. Chovd, Dund-Us, Dzhargalant, Khovd, Jirgalanta
+Zone	Asia/Hovd	6:06:36 -	LMT	1905 Aug
+			6:00	-	+06	1978
+			7:00	Mongol	+07/+08
+# Ulaanbaatar, a.k.a. Ulan Bataar, Ulan Bator, Urga
+Zone	Asia/Ulaanbaatar 7:07:32 -	LMT	1905 Aug
+			7:00	-	+07	1978
+			8:00	Mongol	+08/+09
+# Choibalsan, a.k.a. Bajan Tümen, Bajan Tumen, Chojbalsan,
+# Choybalsan, Sanbejse, Tchoibalsan
+Zone	Asia/Choibalsan	7:38:00 -	LMT	1905 Aug
+			7:00	-	+07	1978
+			8:00	-	+08	1983 Apr
+			9:00	Mongol	+09/+10	2008 Mar 31
+			8:00	Mongol	+08/+09
+
+# Nepal
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Kathmandu	5:41:16 -	LMT	1920
+			5:30	-	+0530	1986
+			5:45	-	+0545
+
+# Oman
+# See Asia/Dubai.
+
+# Pakistan
+
+# From Rives McDow (2002-03-13):
+# I have been advised that Pakistan has decided to adopt dst on a
+# TRIAL basis for one year, starting 00:01 local time on April 7, 2002
+# and ending at 00:01 local time October 6, 2002.  This is what I was
+# told, but I believe that the actual time of change may be 00:00; the
+# 00:01 was to make it clear which day it was on.
+
+# From Paul Eggert (2002-03-15):
+# Jesper Nørgaard found this URL:
+# http://www.pak.gov.pk/public/news/app/app06_dec.htm
+# (dated 2001-12-06) which says that the Cabinet adopted a scheme "to
+# advance the clocks by one hour on the night between the first
+# Saturday and Sunday of April and revert to the original position on
+# 15th October each year".  This agrees with McDow's 04-07 at 00:00,
+# but disagrees about the October transition, and makes it sound like
+# it's not on a trial basis.  Also, the "between the first Saturday
+# and Sunday of April" phrase, if taken literally, means that the
+# transition takes place at 00:00 on the first Sunday on or after 04-02.
+
+# From Paul Eggert (2003-02-09):
+# DAWN <http://www.dawn.com/2002/10/06/top13.htm> reported on 2002-10-05
+# that 2002 DST ended that day at midnight.  Go with McDow for now.
+
+# From Steffen Thorsen (2003-03-14):
+# According to http://www.dawn.com/2003/03/07/top15.htm
+# there will be no DST in Pakistan this year:
+#
+# ISLAMABAD, March 6: Information and Media Development Minister Sheikh
+# Rashid Ahmed on Thursday said the cabinet had reversed a previous
+# decision to advance clocks by one hour in summer and put them back by
+# one hour in winter with the aim of saving light hours and energy.
+#
+# The minister told a news conference that the experiment had rather
+# shown 8 per cent higher consumption of electricity.
+
+# From Alex Krivenyshev (2008-05-15):
+#
+# Here is an article that Pakistan plan to introduce Daylight Saving Time
+# on June 1, 2008 for 3 months.
+#
+# "... The federal cabinet on Wednesday announced a new conservation plan to
+# help reduce load shedding by approving the closure of commercial centres at
+# 9pm and moving clocks forward by one hour for the next three months. ...."
+#
+# http://www.worldtimezone.com/dst_news/dst_news_pakistan01.html
+# http://www.dailytimes.com.pk/default.asp?page=2008%5C05%5C15%5Cstory_15-5-2008_pg1_4
+
+# From Arthur David Olson (2008-05-19):
+# XXX--midnight transitions is a guess; 2008 only is a guess.
+
+# From Alexander Krivenyshev (2008-08-28):
+# Pakistan government has decided to keep the watches one-hour advanced
+# for another 2 months - plan to return to Standard Time on October 31
+# instead of August 31.
+#
+# http://www.worldtimezone.com/dst_news/dst_news_pakistan02.html
+# http://dailymailnews.com/200808/28/news/dmbrn03.html
+
+# From Alexander Krivenyshev (2009-04-08):
+# Based on previous media reports that "... proposed plan to
+# advance clocks by one hour from May 1 will cause disturbance
+# to the working schedules rather than bringing discipline in
+# official working."
+# http://www.thenews.com.pk/daily_detail.asp?id=171280
+#
+# recent news that instead of May 2009 - Pakistan plan to
+# introduce DST from April 15, 2009
+#
+# FYI: Associated Press Of Pakistan
+# April 08, 2009
+# Cabinet okays proposal to advance clocks by one hour from April 15
+# http://www.app.com.pk/en_/index.php?option=com_content&task=view&id=73043&Itemid=1
+# http://www.worldtimezone.com/dst_news/dst_news_pakistan05.html
+#
+# ....
+# The Federal Cabinet on Wednesday approved the proposal to
+# advance clocks in the country by one hour from April 15 to
+# conserve energy"
+
+# From Steffen Thorsen (2009-09-17):
+# "The News International," Pakistan reports that: "The Federal
+# Government has decided to restore the previous time by moving the
+# clocks backward by one hour from October 1. A formal announcement to
+# this effect will be made after the Prime Minister grants approval in
+# this regard."
+# http://www.thenews.com.pk/updates.asp?id=87168
+
+# From Alexander Krivenyshev (2009-09-28):
+# According to Associated Press Of Pakistan, it is confirmed that
+# Pakistan clocks across the country would be turned back by an hour from
+# October 1, 2009.
+#
+# "Clocks to go back one hour from 1 Oct"
+# http://www.app.com.pk/en_/index.php?option=com_content&task=view&id=86715&Itemid=2
+# http://www.worldtimezone.com/dst_news/dst_news_pakistan07.htm
+#
+# From Steffen Thorsen (2009-09-29):
+# Now they seem to have changed their mind, November 1 is the new date:
+# http://www.thenews.com.pk/top_story_detail.asp?Id=24742
+# "The country's clocks will be reversed by one hour on November 1.
+# Officials of Federal Ministry for Interior told this to Geo News on
+# Monday."
+#
+# And more importantly, it seems that these dates will be kept every year:
+# "It has now been decided that clocks will be wound forward by one hour
+# on April 15 and reversed by an hour on November 1 every year without
+# obtaining prior approval, the officials added."
+#
+# We have confirmed this year's end date with both with the Ministry of
+# Water and Power and the Pakistan Electric Power Company:
+# https://www.timeanddate.com/news/time/pakistan-ends-dst09.html
+
+# From Christoph Göhre (2009-10-01):
+# [T]he German Consulate General in Karachi reported me today that Pakistan
+# will go back to standard time on 1st of November.
+
+# From Steffen Thorsen (2010-03-26):
+# Steffen Thorsen wrote:
+# > On Thursday (2010-03-25) it was announced that DST would start in
+# > Pakistan on 2010-04-01.
+# >
+# > Then today, the president said that they might have to revert the
+# > decision if it is not supported by the parliament. So at the time
+# > being, it seems unclear if DST will be actually observed or not - but
+# > April 1 could be a more likely date than April 15.
+# Now, it seems that the decision to not observe DST in final:
+#
+# "Govt Withdraws Plan To Advance Clocks"
+# http://www.apakistannews.com/govt-withdraws-plan-to-advance-clocks-172041
+#
+# "People laud PM's announcement to end DST"
+# http://www.app.com.pk/en_/index.php?option=com_content&task=view&id=99374&Itemid=2
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule Pakistan	2002	only	-	Apr	Sun>=2	0:00	1:00	S
+Rule Pakistan	2002	only	-	Oct	Sun>=2	0:00	0	-
+Rule Pakistan	2008	only	-	Jun	1	0:00	1:00	S
+Rule Pakistan	2008	2009	-	Nov	1	0:00	0	-
+Rule Pakistan	2009	only	-	Apr	15	0:00	1:00	S
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Karachi	4:28:12 -	LMT	1907
+			5:30	-	+0530	1942 Sep
+			5:30	1:00	+0630	1945 Oct 15
+			5:30	-	+0530	1951 Sep 30
+			5:00	-	+05	1971 Mar 26
+			5:00 Pakistan	PK%sT	# Pakistan Time
+
+# Palestine
+
+# From Amos Shapir (1998-02-15):
+#
+# From 1917 until 1948-05-15, all of Palestine, including the parts now
+# known as the Gaza Strip and the West Bank, was under British rule.
+# Therefore the rules given for Israel for that period, apply there too...
+#
+# The Gaza Strip was under Egyptian rule between 1948-05-15 until 1967-06-05
+# (except a short occupation by Israel from 1956-11 till 1957-03, but no
+# time zone was affected then).  It was never formally annexed to Egypt,
+# though.
+#
+# The rest of Palestine was under Jordanian rule at that time, formally
+# annexed in 1950 as the West Bank (and the word "Trans" was dropped from
+# the country's previous name of "the Hashemite Kingdom of the
+# Trans-Jordan").  So the rules for Jordan for that time apply.  Major
+# towns in that area are Nablus (Shchem), El-Halil (Hebron), Ramallah, and
+# East Jerusalem.
+#
+# Both areas were occupied by Israel in June 1967, but not annexed (except
+# for East Jerusalem).  They were on Israel time since then; there might
+# have been a Military Governor's order about time zones, but I'm not aware
+# of any (such orders may have been issued semi-annually whenever summer
+# time was in effect, but maybe the legal aspect of time was just neglected).
+#
+# The Palestinian Authority was established in 1993, and got hold of most
+# towns in the West Bank and Gaza by 1995.  I know that in order to
+# demonstrate...independence, they have been switching to
+# summer time and back on a different schedule than Israel's, but I don't
+# know when this was started, or what algorithm is used (most likely the
+# Jordanian one).
+#
+# To summarize, the table should probably look something like that:
+#
+# Area \ when | 1918-1947 | 1948-1967 | 1967-1995 | 1996-
+# ------------+-----------+-----------+-----------+-----------
+# Israel      | Zion      | Zion      | Zion      | Zion
+# West bank   | Zion      | Jordan    | Zion      | Jordan
+# Gaza        | Zion      | Egypt     | Zion      | Jordan
+#
+# I guess more info may be available from the PA's web page (if/when they
+# have one).
+
+# From Paul Eggert (2006-03-22):
+# Shanks & Pottenger write that Gaza did not observe DST until 1957, but go
+# with Shapir and assume that it observed DST from 1940 through 1947,
+# and that it used Jordanian rules starting in 1996.
+# We don't yet need a separate entry for the West Bank, since
+# the only differences between it and Gaza that we know about
+# occurred before our cutoff date of 1970.
+# However, as we get more information, we may need to add entries
+# for parts of the West Bank as they transitioned from Israel's rules
+# to Palestine's rules.
+
+# From IINS News Service - Israel - 1998-03-23 10:38:07 Israel time,
+# forwarded by Ephraim Silverberg:
+#
+# Despite the fact that Israel changed over to daylight savings time
+# last week, the PLO Authority (PA) has decided not to turn its clocks
+# one-hour forward at this time.  As a sign of independence from Israeli rule,
+# the PA has decided to implement DST in April.
+
+# From Paul Eggert (1999-09-20):
+# Daoud Kuttab writes in Holiday havoc
+# http://www.jpost.com/com/Archive/22.Apr.1999/Opinion/Article-2.html
+# (Jerusalem Post, 1999-04-22) that
+# the Palestinian National Authority changed to DST on 1999-04-15.
+# I vaguely recall that they switch back in October (sorry, forgot the source).
+# For now, let's assume that the spring switch was at 24:00,
+# and that they switch at 0:00 on the 3rd Fridays of April and October.
+
+# From Paul Eggert (2005-11-22):
+# Starting 2004 transitions are from Steffen Thorsen's web site timeanddate.com.
+
+# From Steffen Thorsen (2005-11-23):
+# A user from Gaza reported that Gaza made the change early because of
+# the Ramadan.  Next year Ramadan will be even earlier, so I think
+# there is a good chance next year's end date will be around two weeks
+# earlier - the same goes for Jordan.
+
+# From Steffen Thorsen (2006-08-17):
+# I was informed by a user in Bethlehem that in Bethlehem it started the
+# same day as Israel, and after checking with other users in the area, I
+# was informed that they started DST one day after Israel.  I was not
+# able to find any authoritative sources at the time, nor details if
+# Gaza changed as well, but presumed Gaza to follow the same rules as
+# the West Bank.
+
+# From Steffen Thorsen (2006-09-26):
+# according to the Palestine News Network (2006-09-19):
+# http://english.pnn.ps/index.php?option=com_content&task=view&id=596&Itemid=5
+# > The Council of Ministers announced that this year its winter schedule
+# > will begin early, as of midnight Thursday.  It is also time to turn
+# > back the clocks for winter.  Friday will begin an hour late this week.
+# I guess it is likely that next year's date will be moved as well,
+# because of the Ramadan.
+
+# From Jesper Nørgaard Welen (2007-09-18):
+# According to Steffen Thorsen's web site the Gaza Strip and the rest of the
+# Palestinian territories left DST early on 13.th. of September at 2:00.
+
+# From Paul Eggert (2007-09-20):
+# My understanding is that Gaza and the West Bank disagree even over when
+# the weekend is (Thursday+Friday versus Friday+Saturday), so I'd be a bit
+# surprised if they agreed about DST.  But for now, assume they agree.
+# For lack of better information, predict that future changes will be
+# the 2nd Thursday of September at 02:00.
+
+# From Alexander Krivenyshev (2008-08-28):
+# Here is an article, that Mideast running on different clocks at Ramadan.
+#
+# Gaza Strip (as Egypt) ended DST at midnight Thursday (Aug 28, 2008), while
+# the West Bank will end Daylight Saving Time at midnight Sunday (Aug 31, 2008).
+#
+# http://www.guardian.co.uk/world/feedarticle/7759001
+# http://www.abcnews.go.com/International/wireStory?id=5676087
+# http://www.worldtimezone.com/dst_news/dst_news_gazastrip01.html
+
+# From Alexander Krivenyshev (2009-03-26):
+# According to the Palestine News Network (arabic.pnn.ps), Palestinian
+# government decided to start Daylight Time on Thursday night March
+# 26 and continue until the night of 27 September 2009.
+#
+# (in Arabic)
+# http://arabic.pnn.ps/index.php?option=com_content&task=view&id=50850
+#
+# (English translation)
+# http://www.worldtimezone.com/dst_news/dst_news_westbank01.html
+
+# From Steffen Thorsen (2009-08-31):
+# Palestine's Council of Ministers announced that they will revert back to
+# winter time on Friday, 2009-09-04.
+#
+# One news source:
+# http://www.safa.ps/ara/?action=showdetail&seid=4158
+# (Palestinian press agency, Arabic),
+# Google translate: "Decided that the Palestinian government in Ramallah
+# headed by Salam Fayyad, the start of work in time for the winter of
+# 2009, starting on Friday approved the fourth delay Sept. clock sixty
+# minutes per hour as of Friday morning."
+#
+# We are not sure if Gaza will do the same, last year they had a different
+# end date, we will keep this page updated:
+# https://www.timeanddate.com/news/time/westbank-gaza-dst-2009.html
+
+# From Alexander Krivenyshev (2009-09-02):
+# Seems that Gaza Strip will go back to Winter Time same date as West Bank.
+#
+# According to Palestinian Ministry Of Interior, West Bank and Gaza Strip plan
+# to change time back to Standard time on September 4, 2009.
+#
+# "Winter time unite the West Bank and Gaza"
+# (from Palestinian National Authority):
+# http://www.moi.gov.ps/en/?page=633167343250594025&nid=11505
+# http://www.worldtimezone.com/dst_news/dst_news_gazastrip02.html
+
+# From Alexander Krivenyshev (2010-03-19):
+# According to Voice of Palestine DST will last for 191 days, from March
+# 26, 2010 till "the last Sunday before the tenth day of Tishri
+# (October), each year" (October 03, 2010?)
+#
+# http://palvoice.org/forums/showthread.php?t=245697
+# (in Arabic)
+# http://www.worldtimezone.com/dst_news/dst_news_westbank03.html
+
+# From Steffen Thorsen (2010-03-24):
+# ...Ma'an News Agency reports that Hamas cabinet has decided it will
+# start one day later, at 12:01am. Not sure if they really mean 12:01am or
+# noon though:
+#
+# http://www.maannews.net/eng/ViewDetails.aspx?ID=271178
+# (Ma'an News Agency)
+# "At 12:01am Friday, clocks in Israel and the West Bank will change to
+# 1:01am, while Gaza clocks will change at 12:01am Saturday morning."
+
+# From Steffen Thorsen (2010-08-11):
+# According to several sources, including
+# http://www.maannews.net/eng/ViewDetails.aspx?ID=306795
+# the clocks were set back one hour at 2010-08-11 00:00:00 local time in
+# Gaza and the West Bank.
+# Some more background info:
+# https://www.timeanddate.com/news/time/westbank-gaza-end-dst-2010.html
+
+# From Steffen Thorsen (2011-08-26):
+# Gaza and the West Bank did go back to standard time in the beginning of
+# August, and will now enter daylight saving time again on 2011-08-30
+# 00:00 (so two periods of DST in 2011). The pause was because of
+# Ramadan.
+#
+# http://www.maannews.net/eng/ViewDetails.aspx?ID=416217
+# Additional info:
+# https://www.timeanddate.com/news/time/palestine-dst-2011.html
+
+# From Alexander Krivenyshev (2011-08-27):
+# According to the article in The Jerusalem Post:
+# "...Earlier this month, the Palestinian government in the West Bank decided to
+# move to standard time for 30 days, during Ramadan. The Palestinians in the
+# Gaza Strip accepted the change and also moved their clocks one hour back.
+# The Hamas government said on Saturday that it won't observe summertime after
+# the Muslim feast of Id al-Fitr, which begins on Tuesday..."
+# ...
+# https://www.jpost.com/MiddleEast/Article.aspx?id=235650
+# http://www.worldtimezone.com/dst_news/dst_news_gazastrip05.html
+# The rules for Egypt are stolen from the 'africa' file.
+
+# From Steffen Thorsen (2011-09-30):
+# West Bank did end Daylight Saving Time this morning/midnight (2011-09-30
+# 00:00).
+# So West Bank and Gaza now have the same time again.
+#
+# Many sources, including:
+# http://www.maannews.net/eng/ViewDetails.aspx?ID=424808
+
+# From Steffen Thorsen (2012-03-26):
+# Palestinian news sources tell that both Gaza and West Bank will start DST
+# on Friday (Thursday midnight, 2012-03-29 24:00).
+# Some of many sources in Arabic:
+# http://www.samanews.com/index.php?act=Show&id=122638
+#
+# http://safa.ps/details/news/74352/%D8%A8%D8%AF%D8%A1-%D8%A7%D9%84%D8%AA%D9%88%D9%82%D9%8A%D8%AA-%D8%A7%D9%84%D8%B5%D9%8A%D9%81%D9%8A-%D8%A8%D8%A7%D9%84%D8%B6%D9%81%D8%A9-%D9%88%D8%BA%D8%B2%D8%A9-%D9%84%D9%8A%D9%84%D8%A9-%D8%A7%D9%84%D8%AC%D9%85%D8%B9%D8%A9.html
+#
+# Our brief summary:
+# https://www.timeanddate.com/news/time/gaza-west-bank-dst-2012.html
+
+# From Steffen Thorsen (2013-03-26):
+# The following news sources tells that Palestine will "start daylight saving
+# time from midnight on Friday, March 29, 2013" (translated).
+# [These are in Arabic and are for Gaza and for Ramallah, respectively.]
+# http://www.samanews.com/index.php?act=Show&id=154120
+# http://safa.ps/details/news/99844/%D8%B1%D8%A7%D9%85-%D8%A7%D9%84%D9%84%D9%87-%D8%A8%D8%AF%D8%A1-%D8%A7%D9%84%D8%AA%D9%88%D9%82%D9%8A%D8%AA-%D8%A7%D9%84%D8%B5%D9%8A%D9%81%D9%8A-29-%D8%A7%D9%84%D8%AC%D8%A7%D8%B1%D9%8A.html
+
+# From Steffen Thorsen (2013-09-24):
+# The Gaza and West Bank are ending DST Thursday at midnight
+# (2013-09-27 00:00:00) (one hour earlier than last year...).
+# This source in English, says "that winter time will go into effect
+# at midnight on Thursday in the West Bank and Gaza Strip":
+# http://english.wafa.ps/index.php?action=detail&id=23246
+# official source...:
+# http://www.palestinecabinet.gov.ps/ar/Views/ViewDetails.aspx?pid=1252
+
+# From Steffen Thorsen (2015-03-03):
+# Sources such as http://www.alquds.com/news/article/view/id/548257
+# and https://www.raya.ps/ar/news/890705.html say Palestine areas will
+# start DST on 2015-03-28 00:00 which is one day later than expected.
+#
+# From Paul Eggert (2015-03-03):
+# https://www.timeanddate.com/time/change/west-bank/ramallah?year=2014
+# says that the fall 2014 transition was Oct 23 at 24:00.
+
+# From Hannah Kreitem (2016-03-09):
+# http://www.palestinecabinet.gov.ps/WebSite/ar/ViewDetails?ID=31728
+# [Google translation]: "The Council also decided to start daylight
+# saving in Palestine as of one o'clock on Saturday morning,
+# 2016-03-26, to provide the clock 60 minutes ahead."
+
+# From Sharef Mustafa (2016-10-19):
+# [T]he Palestinian cabinet decision (Mar 8th 2016) published on
+# http://www.palestinecabinet.gov.ps/WebSite/Upload/Decree/GOV_17/16032016134830.pdf
+# states that summer time will end on Oct 29th at 01:00.
+
+# From Sharef Mustafa (2018-03-16):
+# Palestine summer time will start on Mar 24th 2018 ...
+# http://www.palestinecabinet.gov.ps/Website/AR/NDecrees/ViewFile.ashx?ID=e7a42ab7-ee23-435a-b9c8-a4f7e81f3817
+
+# From Even Scharning (2019-03-23):
+# http://pnn.ps/news/401130
+# http://palweather.ps/ar/node/50136.html
+#
+# From Sharif Mustafa (2019-03-26):
+# The Palestinian cabinet announced today that the switch to DST will
+# be on Fri Mar 29th 2019 by advancing the clock by 60 minutes.
+# http://palestinecabinet.gov.ps/Website/AR/NDecrees/ViewFile.ashx?ID=e54e9ea1-50ee-4137-84df-0d6c78da259b
+#
+# From Even Scharning (2019-04-10):
+# Our source in Palestine said it happened Friday 29 at 00:00 local time....
+
+# From Sharef Mustafa (2019-10-18):
+# Palestine summer time will end on midnight Oct 26th 2019 ...
+# http://www.palestinecabinet.gov.ps/website/ar/ViewDetails?ID=43948
+#
+# From Paul Eggert (2019-04-10):
+# For now, guess spring-ahead transitions are March's last Friday at 00:00.
+#
+# From Tim Parenti (2016-10-19):
+# Predict fall transitions on October's last Saturday at 01:00 from now on.
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule EgyptAsia	1957	only	-	May	10	0:00	1:00	S
+Rule EgyptAsia	1957	1958	-	Oct	 1	0:00	0	-
+Rule EgyptAsia	1958	only	-	May	 1	0:00	1:00	S
+Rule EgyptAsia	1959	1967	-	May	 1	1:00	1:00	S
+Rule EgyptAsia	1959	1965	-	Sep	30	3:00	0	-
+Rule EgyptAsia	1966	only	-	Oct	 1	3:00	0	-
+
+Rule Palestine	1999	2005	-	Apr	Fri>=15	0:00	1:00	S
+Rule Palestine	1999	2003	-	Oct	Fri>=15	0:00	0	-
+Rule Palestine	2004	only	-	Oct	 1	1:00	0	-
+Rule Palestine	2005	only	-	Oct	 4	2:00	0	-
+Rule Palestine	2006	2007	-	Apr	 1	0:00	1:00	S
+Rule Palestine	2006	only	-	Sep	22	0:00	0	-
+Rule Palestine	2007	only	-	Sep	Thu>=8	2:00	0	-
+Rule Palestine	2008	2009	-	Mar	lastFri	0:00	1:00	S
+Rule Palestine	2008	only	-	Sep	 1	0:00	0	-
+Rule Palestine	2009	only	-	Sep	Fri>=1	1:00	0	-
+Rule Palestine	2010	only	-	Mar	26	0:00	1:00	S
+Rule Palestine	2010	only	-	Aug	11	0:00	0	-
+Rule Palestine	2011	only	-	Apr	 1	0:01	1:00	S
+Rule Palestine	2011	only	-	Aug	 1	0:00	0	-
+Rule Palestine	2011	only	-	Aug	30	0:00	1:00	S
+Rule Palestine	2011	only	-	Sep	30	0:00	0	-
+Rule Palestine	2012	2014	-	Mar	lastThu	24:00	1:00	S
+Rule Palestine	2012	only	-	Sep	21	1:00	0	-
+Rule Palestine	2013	only	-	Sep	Fri>=21	0:00	0	-
+Rule Palestine	2014	2015	-	Oct	Fri>=21	0:00	0	-
+Rule Palestine	2015	only	-	Mar	lastFri	24:00	1:00	S
+Rule Palestine	2016	2018	-	Mar	Sat>=24	1:00	1:00	S
+Rule Palestine	2016	max	-	Oct	lastSat	1:00	0	-
+Rule Palestine	2019	max	-	Mar	lastFri	0:00	1:00	S
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Gaza	2:17:52	-	LMT	1900 Oct
+			2:00	Zion	EET/EEST 1948 May 15
+			2:00 EgyptAsia	EE%sT	1967 Jun  5
+			2:00	Zion	I%sT	1996
+			2:00	Jordan	EE%sT	1999
+			2:00 Palestine	EE%sT	2008 Aug 29  0:00
+			2:00	-	EET	2008 Sep
+			2:00 Palestine	EE%sT	2010
+			2:00	-	EET	2010 Mar 27  0:01
+			2:00 Palestine	EE%sT	2011 Aug  1
+			2:00	-	EET	2012
+			2:00 Palestine	EE%sT
+
+Zone	Asia/Hebron	2:20:23	-	LMT	1900 Oct
+			2:00	Zion	EET/EEST 1948 May 15
+			2:00 EgyptAsia	EE%sT	1967 Jun  5
+			2:00	Zion	I%sT	1996
+			2:00	Jordan	EE%sT	1999
+			2:00 Palestine	EE%sT
+
+# Paracel Is
+# no information
+
+# Philippines
+
+# From Paul Eggert (2018-11-18):
+# The Spanish initially used American (west-of-Greenwich) time.
+# It is unknown what time Manila kept when the British occupied it from
+# 1762-10-06 through 1764-04; for now assume it kept American time.
+# On 1844-08-16, Narciso Clavería, governor-general of the
+# Philippines, issued a proclamation announcing that 1844-12-30 was to
+# be immediately followed by 1845-01-01; see R.H. van Gent's
+# History of the International Date Line
+# https://www.staff.science.uu.nl/~gent0113/idl/idl_philippines.htm
+# The rest of the data entries are from Shanks & Pottenger.
+
+# From Jesper Nørgaard Welen (2006-04-26):
+# ... claims that Philippines had DST last time in 1990:
+# http://story.philippinetimes.com/p.x/ct/9/id/145be20cc6b121c0/cid/3e5bbccc730d258c/
+# [a story dated 2006-04-25 by Cris Larano of Dow Jones Newswires,
+# but no details]
+
+# From Paul Eggert (2014-08-14):
+# The following source says DST may be instituted November-January and again
+# March-June, but this is not definite.  It also says DST was last proclaimed
+# during the Ramos administration (1992-1998); but again, no details.
+# Carcamo D. PNoy urged to declare use of daylight saving time.
+# Philippine Star 2014-08-05
+# http://www.philstar.com/headlines/2014/08/05/1354152/pnoy-urged-declare-use-daylight-saving-time
+
+# From Paul Goyette (2018-06-15):
+# In the Philippines, there is a national law, Republic Act No. 10535
+# which declares the official time here as "Philippine Standard Time".
+# The act [1] even specifies use of PST as the abbreviation, although
+# the FAQ provided by PAGASA [2] uses the "acronym PhST to distinguish
+# it from the Pacific Standard Time (PST)."
+# [1] http://www.officialgazette.gov.ph/2013/05/15/republic-act-no-10535/
+# [2] https://www1.pagasa.dost.gov.ph/index.php/astronomy/philippine-standard-time#republic-act-10535
+#
+# From Paul Eggert (2018-06-19):
+# I surveyed recent news reports, and my impression is that "PST" is
+# more popular among reliable English-language news sources.  This is
+# not just a measure of Google hit counts: it's also the sizes and
+# influence of the sources.  There is no current abbreviation for DST,
+# so use "PDT", the usual American style.
+
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Phil	1936	only	-	Nov	1	0:00	1:00	D
+Rule	Phil	1937	only	-	Feb	1	0:00	0	S
+Rule	Phil	1954	only	-	Apr	12	0:00	1:00	D
+Rule	Phil	1954	only	-	Jul	1	0:00	0	S
+Rule	Phil	1978	only	-	Mar	22	0:00	1:00	D
+Rule	Phil	1978	only	-	Sep	21	0:00	0	S
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Manila	-15:56:00 -	LMT	1844 Dec 31
+			8:04:00 -	LMT	1899 May 11
+			8:00	Phil	P%sT	1942 May
+			9:00	-	JST	1944 Nov
+			8:00	Phil	P%sT
+
+# Qatar
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Qatar	3:26:08 -	LMT	1920     # Al Dawhah / Doha
+			4:00	-	+04	1972 Jun
+			3:00	-	+03
+Link Asia/Qatar Asia/Bahrain
+
+# Saudi Arabia
+#
+# From Paul Eggert (2018-08-29):
+# Time in Saudi Arabia and other countries in the Arabian peninsula was not
+# standardized until 1968 or so; we don't know exactly when, and possibly it
+# has never been made official.  Richard P Hunt, in "Islam city yielding to
+# modern times", New York Times (1961-04-09), p 20, wrote that only airlines
+# observed standard time, and that people in Jeddah mostly observed quasi-solar
+# time, doing so by setting their watches at sunrise to 6 o'clock (or to 12
+# o'clock for "Arab" time).
+#
+# Timekeeping differed depending on who you were and which part of Saudi
+# Arabia you were in.  In 1969, Elias Antar wrote that although a common
+# practice had been to set one's watch to 12:00 (i.e., midnight) at sunset -
+# which meant that the time on one side of a mountain could differ greatly from
+# the time on the other side - many foreigners set their watches to 6pm
+# instead, while airlines instead used UTC +03 (except in Dhahran, where they
+# used UTC +04), Aramco used UTC +03 with DST, and the Trans-Arabian Pipe Line
+# Company used Aramco time in eastern Saudi Arabia and airline time in western.
+# (The American Military Aid Advisory Group used plain UTC.)  Antar writes,
+# "A man named Higgins, so the story goes, used to run a local power
+# station. One day, the whole thing became too much for Higgins and he
+# assembled his staff and laid down the law. 'I've had enough of this,' he
+# shrieked. 'It is now 12 o'clock Higgins Time, and from now on this station is
+# going to run on Higgins Time.' And so, until last year, it did."  See:
+# Antar E. Dinner at When? Saudi Aramco World, 1969 March/April. 2-3.
+# http://archive.aramcoworld.com/issue/196902/dinner.at.when.htm
+# Also see: Antar EN. Arabian flying is confusing.
+# Port Angeles (WA) Evening News. 1965-03-10. page 3.
+#
+# The TZ database cannot represent quasi-solar time; airline time is the best
+# we can do.  The 1946 foreign air news digest of the U.S. Civil Aeronautics
+# Board (OCLC 42299995) reported that the "... Arabian Government, inaugurated
+# a weekly Dhahran-Cairo service, via the Saudi Arabian cities of Riyadh and
+# Jidda, on March 14, 1947".  Shanks & Pottenger guessed 1950; go with the
+# earlier date.
+#
+# Shanks & Pottenger also state that until 1968-05-01 Saudi Arabia had two
+# time zones; the other zone, at UT +04, was in the far eastern part of
+# the country.  Presumably this is documenting airline time.  Ignore this,
+# as it's before our 1970 cutoff.
+#
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Riyadh	3:06:52 -	LMT	1947 Mar 14
+			3:00	-	+03
+Link Asia/Riyadh Asia/Aden	# Yemen
+Link Asia/Riyadh Asia/Kuwait
+
+# Singapore
+# taken from Mok Ly Yng (2003-10-30)
+# http://www.math.nus.edu.sg/aslaksen/teaching/timezone.html
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Singapore	6:55:25 -	LMT	1901 Jan  1
+			6:55:25	-	SMT	1905 Jun  1 # Singapore M.T.
+			7:00	-	+07	1933 Jan  1
+			7:00	0:20	+0720	1936 Jan  1
+			7:20	-	+0720	1941 Sep  1
+			7:30	-	+0730	1942 Feb 16
+			9:00	-	+09	1945 Sep 12
+			7:30	-	+0730	1982 Jan  1
+			8:00	-	+08
+
+# Spratly Is
+# no information
+
+# Sri Lanka
+
+# From Paul Eggert (2013-02-21):
+# Milne says "Madras mean time use from May 1, 1898.  Prior to this Colombo
+# mean time, 5h. 4m. 21.9s. F., was used."  But 5:04:21.9 differs considerably
+# from Colombo's meridian 5:19:24, so for now ignore Milne and stick with
+# Shanks and Pottenger.
+
+# From Paul Eggert (1996-09-03):
+# "Sri Lanka advances clock by an hour to avoid blackout"
+# (<http://www.virtual-pc.com/lankaweb/news/items/240596-2.html>, 1996-05-24,
+# no longer available as of 1999-08-17)
+# reported "the country's standard time will be put forward by one hour at
+# midnight Friday (1830 GMT) 'in the light of the present power crisis'."
+#
+# From Dharmasiri Senanayake, Sri Lanka Media Minister (1996-10-24), as quoted
+# by Shamindra in Daily News - Hot News Section
+# <news:54rka5$m5h@mtinsc01-mgt.ops.worldnet.att.net> (1996-10-26):
+# With effect from 12.30 a.m. on 26th October 1996
+# Sri Lanka will be six (06) hours ahead of GMT.
+
+# From Jesper Nørgaard Welen (2006-04-14), quoting Sri Lanka News Online
+# <http://news.sinhalaya.com/wmview.php?ArtID=11002> (2006-04-13):
+# 0030 hrs on April 15, 2006 (midnight of April 14, 2006 +30 minutes)
+# at present, become 2400 hours of April 14, 2006 (midnight of April 14, 2006).
+
+# From Peter Apps and Ranga Sirila of Reuters (2006-04-12) in:
+# http://today.reuters.co.uk/news/newsArticle.aspx?type=scienceNews&storyID=2006-04-12T172228Z_01_COL295762_RTRIDST_0_SCIENCE-SRILANKA-TIME-DC.XML
+# [The Tamil Tigers] never accepted the original 1996 time change and simply
+# kept their clocks set five and a half hours ahead of Greenwich Mean
+# Time (GMT), in line with neighbor India.
+# From Paul Eggert (2006-04-18):
+# People who live in regions under Tamil control can use [TZ='Asia/Kolkata'],
+# as that zone has agreed with the Tamil areas since our cutoff date of 1970.
+
+# From Sadika Sumanapala (2016-10-19):
+# According to http://www.sltime.org (maintained by Measurement Units,
+# Standards & Services Department, Sri Lanka) abbreviation for Sri Lanka
+# standard time is SLST.
+#
+# From Paul Eggert (2016-10-18):
+# "SLST" seems to be reasonably recent and rarely-used outside time
+# zone nerd sources.  I searched Google News and found three uses of
+# it in the International Business Times of India in February and
+# March of this year when discussing cricket match times, but nothing
+# since then (though there has been a lot of cricket) and nothing in
+# other English-language news sources.  Our old abbreviation "LKT" is
+# even worse.  For now, let's use a numeric abbreviation; we can
+# switch to "SLST" if it catches on.
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Colombo	5:19:24 -	LMT	1880
+			5:19:32	-	MMT	1906        # Moratuwa Mean Time
+			5:30	-	+0530	1942 Jan  5
+			5:30	0:30	+06	1942 Sep
+			5:30	1:00	+0630	1945 Oct 16  2:00
+			5:30	-	+0530	1996 May 25  0:00
+			6:30	-	+0630	1996 Oct 26  0:30
+			6:00	-	+06	2006 Apr 15  0:30
+			5:30	-	+0530
+
+# Syria
+# Rule	NAME	FROM	TO	TYPE	IN	ON	AT	SAVE	LETTER/S
+Rule	Syria	1920	1923	-	Apr	Sun>=15	2:00	1:00	S
+Rule	Syria	1920	1923	-	Oct	Sun>=1	2:00	0	-
+Rule	Syria	1962	only	-	Apr	29	2:00	1:00	S
+Rule	Syria	1962	only	-	Oct	1	2:00	0	-
+Rule	Syria	1963	1965	-	May	1	2:00	1:00	S
+Rule	Syria	1963	only	-	Sep	30	2:00	0	-
+Rule	Syria	1964	only	-	Oct	1	2:00	0	-
+Rule	Syria	1965	only	-	Sep	30	2:00	0	-
+Rule	Syria	1966	only	-	Apr	24	2:00	1:00	S
+Rule	Syria	1966	1976	-	Oct	1	2:00	0	-
+Rule	Syria	1967	1978	-	May	1	2:00	1:00	S
+Rule	Syria	1977	1978	-	Sep	1	2:00	0	-
+Rule	Syria	1983	1984	-	Apr	9	2:00	1:00	S
+Rule	Syria	1983	1984	-	Oct	1	2:00	0	-
+Rule	Syria	1986	only	-	Feb	16	2:00	1:00	S
+Rule	Syria	1986	only	-	Oct	9	2:00	0	-
+Rule	Syria	1987	only	-	Mar	1	2:00	1:00	S
+Rule	Syria	1987	1988	-	Oct	31	2:00	0	-
+Rule	Syria	1988	only	-	Mar	15	2:00	1:00	S
+Rule	Syria	1989	only	-	Mar	31	2:00	1:00	S
+Rule	Syria	1989	only	-	Oct	1	2:00	0	-
+Rule	Syria	1990	only	-	Apr	1	2:00	1:00	S
+Rule	Syria	1990	only	-	Sep	30	2:00	0	-
+Rule	Syria	1991	only	-	Apr	 1	0:00	1:00	S
+Rule	Syria	1991	1992	-	Oct	 1	0:00	0	-
+Rule	Syria	1992	only	-	Apr	 8	0:00	1:00	S
+Rule	Syria	1993	only	-	Mar	26	0:00	1:00	S
+Rule	Syria	1993	only	-	Sep	25	0:00	0	-
+# IATA SSIM (1998-02) says 1998-04-02;
+# (1998-09) says 1999-03-29 and 1999-09-29; (1999-02) says 1999-04-02,
+# 2000-04-02, and 2001-04-02; (1999-09) says 2000-03-31 and 2001-03-31;
+# (2006) says 2006-03-31 and 2006-09-22;
+# for now ignore all these claims and go with Shanks & Pottenger,
+# except for the 2006-09-22 claim (which seems right for Ramadan).
+Rule	Syria	1994	1996	-	Apr	 1	0:00	1:00	S
+Rule	Syria	1994	2005	-	Oct	 1	0:00	0	-
+Rule	Syria	1997	1998	-	Mar	lastMon	0:00	1:00	S
+Rule	Syria	1999	2006	-	Apr	 1	0:00	1:00	S
+# From Stephen Colebourne (2006-09-18):
+# According to IATA data, Syria will change DST on 21st September [21:00 UTC]
+# this year [only]....  This is probably related to Ramadan, like Egypt.
+Rule	Syria	2006	only	-	Sep	22	0:00	0	-
+# From Paul Eggert (2007-03-29):
+# Today the AP reported "Syria will switch to summertime at midnight Thursday."
+# http://www.iht.com/articles/ap/2007/03/29/africa/ME-GEN-Syria-Time-Change.php
+Rule	Syria	2007	only	-	Mar	lastFri	0:00	1:00	S
+# From Jesper Nørgaard (2007-10-27):
+# The sister center ICARDA of my work CIMMYT is confirming that Syria DST will
+# not take place 1st November at 0:00 o'clock but 1st November at 24:00 or
+# rather Midnight between Thursday and Friday. This does make more sense than
+# having it between Wednesday and Thursday (two workdays in Syria) since the
+# weekend in Syria is not Saturday and Sunday, but Friday and Saturday. So now
+# it is implemented at midnight of the last workday before weekend...
+#
+# From Steffen Thorsen (2007-10-27):
+# Jesper Nørgaard Welen wrote:
+#
+# > "Winter local time in Syria will be observed at midnight of Thursday 1
+# > November 2007, and the clock will be put back 1 hour."
+#
+# I found confirmation on this in this gov.sy-article (Arabic):
+# http://wehda.alwehda.gov.sy/_print_veiw.asp?FileName=12521710520070926111247
+#
+# which using Google's translate tools says:
+# Council of Ministers also approved the commencement of work on
+# identifying the winter time as of Friday, 2/11/2007 where the 60th
+# minute delay at midnight Thursday 1/11/2007.
+Rule	Syria	2007	only	-	Nov	 Fri>=1	0:00	0	-
+
+# From Stephen Colebourne (2008-03-17):
+# For everyone's info, I saw an IATA time zone change for [Syria] for
+# this month (March 2008) in the last day or so....
+# Country     Time Standard   --- DST Start ---   --- DST End ---  DST
+# Name        Zone Variation   Time    Date        Time    Date
+# Variation
+# Syrian Arab
+# Republic    SY    +0200      2200  03APR08       2100  30SEP08   +0300
+#                              2200  02APR09       2100  30SEP09   +0300
+#                              2200  01APR10       2100  30SEP10   +0300
+
+# From Arthur David Olson (2008-03-17):
+# Here's a link to English-language coverage by the Syrian Arab News
+# Agency (SANA)...
+# http://www.sana.sy/eng/21/2008/03/11/165173.htm
+# ...which reads (in part) "The Cabinet approved the suggestion of the
+# Ministry of Electricity to begin daylight savings time on Friday April
+# 4th, advancing clocks one hour ahead on midnight of Thursday April 3rd."
+# Since Syria is two hours east of UTC, the 2200 and 2100 transition times
+# shown above match up with midnight in Syria.
+
+# From Arthur David Olson (2008-03-18):
+# My best guess at a Syrian rule is "the Friday nearest April 1";
+# coding that involves either using a "Mar Fri>=29" construct that old time zone
+# compilers can't handle  or having multiple Rules (a la Israel).
+# For now, use "Apr Fri>=1", and go with IATA on a uniform Sep 30 end.
+
+# From Steffen Thorsen (2008-10-07):
+# Syria has now officially decided to end DST on 2008-11-01 this year,
+# according to the following article in the Syrian Arab News Agency (SANA).
+#
+# The article is in Arabic, and seems to tell that they will go back to
+# winter time on 2008-11-01 at 00:00 local daylight time (delaying/setting
+# clocks back 60 minutes).
+#
+# http://sana.sy/ara/2/2008/10/07/195459.htm
+
+# From Steffen Thorsen (2009-03-19):
+# Syria will start DST on 2009-03-27 00:00 this year according to many sources,
+# two examples:
+#
+# http://www.sana.sy/eng/21/2009/03/17/217563.htm
+# (English, Syrian Arab News # Agency)
+# http://thawra.alwehda.gov.sy/_View_news2.asp?FileName=94459258720090318012209
+# (Arabic, gov-site)
+#
+# We have not found any sources saying anything about when DST ends this year.
+#
+# Our summary
+# https://www.timeanddate.com/news/time/syria-dst-starts-march-27-2009.html
+
+# From Steffen Thorsen (2009-10-27):
+# The Syrian Arab News Network on 2009-09-29 reported that Syria will
+# revert back to winter (standard) time on midnight between Thursday
+# 2009-10-29 and Friday 2009-10-30:
+# http://www.sana.sy/ara/2/2009/09/29/247012.htm (Arabic)
+
+# From Arthur David Olson (2009-10-28):
+# We'll see if future DST switching times turn out to be end of the last
+# Thursday of the month or the start of the last Friday of the month or
+# something else. For now, use the start of the last Friday.
+
+# From Steffen Thorsen (2010-03-17):
+# The "Syrian News Station" reported on 2010-03-16 that the Council of
+# Ministers has decided that Syria will start DST on midnight Thursday
+# 2010-04-01: (midnight between Thursday and Friday):
+# http://sns.sy/sns/?path=news/read/11421 (Arabic)
+
+# From Steffen Thorsen (2012-03-26):
+# Today, Syria's government announced that they will start DST early on Friday
+# (00:00). This is a bit earlier than the past two years.
+#
+# From Syrian Arab News Agency, in Arabic:
+# http://www.sana.sy/ara/2/2012/03/26/408215.htm
+#
+# Our brief summary:
+# https://www.timeanddate.com/news/time/syria-dst-2012.html
+
+# From Arthur David Olson (2012-03-27):
+# Assume last Friday in March going forward XXX.
+
+Rule	Syria	2008	only	-	Apr	Fri>=1	0:00	1:00	S
+Rule	Syria	2008	only	-	Nov	1	0:00	0	-
+Rule	Syria	2009	only	-	Mar	lastFri	0:00	1:00	S
+Rule	Syria	2010	2011	-	Apr	Fri>=1	0:00	1:00	S
+Rule	Syria	2012	max	-	Mar	lastFri	0:00	1:00	S
+Rule	Syria	2009	max	-	Oct	lastFri	0:00	0	-
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Damascus	2:25:12 -	LMT	1920 # Dimashq
+			2:00	Syria	EE%sT
+
+# Tajikistan
+# From Shanks & Pottenger.
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Dushanbe	4:35:12 -	LMT	1924 May  2
+			5:00	-	+05	1930 Jun 21
+			6:00 RussiaAsia +06/+07	1991 Mar 31  2:00s
+			5:00	1:00	+05/+06	1991 Sep  9  2:00s
+			5:00	-	+05
+
+# Thailand
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Bangkok	6:42:04	-	LMT	1880
+			6:42:04	-	BMT	1920 Apr # Bangkok Mean Time
+			7:00	-	+07
+Link Asia/Bangkok Asia/Phnom_Penh	# Cambodia
+Link Asia/Bangkok Asia/Vientiane	# Laos
+
+# Turkmenistan
+# From Shanks & Pottenger.
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Ashgabat	3:53:32 -	LMT	1924 May  2 # or Ashkhabad
+			4:00	-	+04	1930 Jun 21
+			5:00 RussiaAsia	+05/+06	1991 Mar 31  2:00
+			4:00 RussiaAsia	+04/+05	1992 Jan 19  2:00
+			5:00	-	+05
+
+# United Arab Emirates
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Dubai	3:41:12 -	LMT	1920
+			4:00	-	+04
+Link Asia/Dubai Asia/Muscat	# Oman
+
+# Uzbekistan
+# Byalokoz 1919 says Uzbekistan was 4:27:53.
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone	Asia/Samarkand	4:27:53 -	LMT	1924 May  2
+			4:00	-	+04	1930 Jun 21
+			5:00	-	+05	1981 Apr  1
+			5:00	1:00	+06	1981 Oct  1
+			6:00	-	+06	1982 Apr  1
+			5:00 RussiaAsia	+05/+06	1992
+			5:00	-	+05
+# Milne says Tashkent was 4:37:10.8; round to nearest.
+Zone	Asia/Tashkent	4:37:11 -	LMT	1924 May  2
+			5:00	-	+05	1930 Jun 21
+			6:00 RussiaAsia	+06/+07	1991 Mar 31  2:00
+			5:00 RussiaAsia	+05/+06	1992
+			5:00	-	+05
+
+# Vietnam
+
+# From Paul Eggert (2014-10-04):
+# Milne gives 7:16:56 for the meridian of Saigon in 1899, as being
+# used in Lower Laos, Cambodia, and Annam.  But this is quite a ways
+# from Saigon's location.  For now, ignore this and stick with Shanks
+# and Pottenger for LMT before 1906.
+
+# From Arthur David Olson (2008-03-18):
+# The English-language name of Vietnam's most populous city is "Ho Chi Minh
+# City"; use Ho_Chi_Minh below to avoid a name of more than 14 characters.
+
+# From Paul Eggert (2014-10-21) after a heads-up from Trần Ngọc Quân:
+# Trần Tiến Bình's authoritative book "Lịch Việt Nam: thế kỷ XX-XXI (1901-2100)"
+# (Nhà xuất bản Văn Hoá - Thông Tin, Hanoi, 2005), pp 49-50,
+# is quoted verbatim in:
+# http://www.thoigian.com.vn/?mPage=P80D01
+# is translated by Brian Inglis in:
+# https://mm.icann.org/pipermail/tz/2014-October/021654.html
+# and is the basis for the information below.
+#
+# The 1906 transition was effective July 1 and standardized Indochina to
+# Phù Liễn Observatory, legally 104° 17' 17" east of Paris.
+# It's unclear whether this meant legal Paris Mean Time (00:09:21) or
+# the Paris Meridian (2° 20' 14.03" E); the former yields 07:06:30.1333...
+# and the latter 07:06:29.333... so either way it rounds to 07:06:30,
+# which is used below even though the modern-day Phù Liễn Observatory
+# is closer to 07:06:31.  Abbreviate Phù Liễn Mean Time as PLMT.
+#
+# The following transitions occurred in Indochina in general (before 1954)
+# and in South Vietnam in particular (after 1954):
+# To 07:00 on 1911-05-01.
+# To 08:00 on 1942-12-31 at 23:00.
+# To 09:00 on 1945-03-14 at 23:00.
+# To 07:00 on 1945-09-02 in Vietnam.
+# To 08:00 on 1947-04-01 in French-controlled Indochina.
+# To 07:00 on 1955-07-01 in South Vietnam.
+# To 08:00 on 1959-12-31 at 23:00 in South Vietnam.
+# To 07:00 on 1975-06-13 in South Vietnam.
+#
+# Trần cites the following sources; it's unclear which supplied the info above.
+#
+# Hoàng Xuân Hãn: "Lịch và lịch Việt Nam". Tập san Khoa học Xã hội,
+# No. 9, Paris, February 1982.
+#
+# Lê Thành Lân: "Lịch và niên biểu lịch sử hai mươi thế kỷ (0001-2010)",
+# NXB Thống kê, Hanoi, 2000.
+#
+# Lê Thành Lân: "Lịch hai thế kỷ (1802-2010) và các lịch vĩnh cửu",
+# NXB Thuận Hoá, Huế, 1995.
+
+# Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
+Zone Asia/Ho_Chi_Minh	7:06:40 -	LMT	1906 Jul  1
+			7:06:30	-	PLMT	1911 May  1 # Phù Liễn MT
+			7:00	-	+07	1942 Dec 31 23:00
+			8:00	-	+08	1945 Mar 14 23:00
+			9:00	-	+09	1945 Sep  2
+			7:00	-	+07	1947 Apr  1
+			8:00	-	+08	1955 Jul  1
+			7:00	-	+07	1959 Dec 31 23:00
+			8:00	-	+08	1975 Jun 13
+			7:00	-	+07
+
+# From Paul Eggert (2019-02-19):
+#
+# The Ho Chi Minh entry suffices for most purposes as it agrees with all of
+# Vietnam since 1975-06-13.  Presumably clocks often changed in south Vietnam
+# in the early 1970s as locations changed hands during the war; however the
+# details are unknown and would likely be too voluminous for this database.
+#
+# For timestamps in north Vietnam back to 1970 (the tzdb cutoff),
+# use Asia/Bangkok; see the VN entries in the file zone1970.tab.
+# For timestamps before 1970, see Asia/Hanoi in the file 'backzone'.
+
+
+# Yemen
+# See Asia/Riyadh.
diff --git a/examples/benchmark.rs b/examples/benchmark.rs
new file mode 100644
index 0000000..bc80ed9
--- /dev/null
+++ b/examples/benchmark.rs
@@ -0,0 +1,34 @@
+extern crate parse_zoneinfo;
+
+use parse_zoneinfo::line::{LineParser, Line};
+use parse_zoneinfo::table::TableBuilder;
+
+// This function is needed until zoneinfo_parse handles comments correctly.
+// Technically a '#' symbol could occur between double quotes and should be
+// ignored in this case, however this never happens in the tz database as it
+// stands.
+fn strip_comments(mut line: String) -> String {
+    line.find('#').map(|pos| line.truncate(pos));
+    line
+}
+
+fn main() {
+    let lines = std::fs::read_to_string("examples/asia").unwrap().lines().map(|line| {
+        strip_comments(line.to_string())
+    }).collect::<Vec<_>>();
+
+    for _ in 0..100 {
+        let parser = LineParser::new();
+        let mut builder = TableBuilder::new();
+        for line in &lines {
+            match parser.parse_str(&line).unwrap() {
+                Line::Zone(zone) => builder.add_zone_line(zone).unwrap(),
+                Line::Continuation(cont) => builder.add_continuation_line(cont).unwrap(),
+                Line::Rule(rule) => builder.add_rule_line(rule).unwrap(),
+                Line::Link(link) => builder.add_link_line(link).unwrap(),
+                Line::Space => {},
+            }
+        }
+        let _table = builder.build();
+    }
+}

From aaad994d9ebf8f91055fd69ab9bb2f62b5ece1f4 Mon Sep 17 00:00:00 2001
From: Ran Benita <ran@unusedvar.com>
Date: Thu, 24 Oct 2019 22:48:30 +0300
Subject: [PATCH 081/113] Improve build time by turning off regex cargo
 features

Only enable the regex features we need. See here for reference:
https://docs.rs/regex/1.3.1/regex/#crate-features

This reduces compilation time in release mode on my computer from ~30s
to ~16s (~50% decrease).

This increases the benchmark runtime on my computer in release mode with
`-C target-cpu=native` from ~0.5s to ~0.65s (~%30 increase).

chrono-tz uses this crate at build time to parse a few files, in which
case runtime speed is not super important, while compilation speed is.

If a crate does require maximum speed, it can enable regex's `perf`
feature in their own Cargo.toml.
---
 Cargo.toml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 4e92973..82a3871 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,5 +8,7 @@ repository = "https://github.com/djzin/parse-zoneinfo"
 readme = "README.md"
 license = "MIT"
 
-[dependencies]
-regex = "1"
+[dependencies.regex]
+version = "1.3.1"
+default-features = false
+features = ["std", "unicode-perl"]

From 0ad777c371e79be6aa298fddcc750a1224a8c6b0 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <quodlibetor@gmail.com>
Date: Fri, 20 Dec 2019 10:24:47 -0500
Subject: [PATCH 082/113] Configure github actions to test on push

---
 .github/workflows/rust-test.yml | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 .github/workflows/rust-test.yml

diff --git a/.github/workflows/rust-test.yml b/.github/workflows/rust-test.yml
new file mode 100644
index 0000000..312cbfd
--- /dev/null
+++ b/.github/workflows/rust-test.yml
@@ -0,0 +1,15 @@
+name: Rust
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose

From 15df80c93a3c5b3174faa0c7fe164137b6601137 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Sat, 21 Dec 2019 13:01:12 -0500
Subject: [PATCH 083/113] Add a changelog, bump the version

---
 CHANGELOG.md | 6 ++++++
 Cargo.toml   | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)
 create mode 100644 CHANGELOG.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..e78f907
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,6 @@
+Changes to parse-zoneinfo
+=========================
+
+# 0.2.1
+
+- Build faster by relying on fewer regex features (PR #6 by @bluetech)
diff --git a/Cargo.toml b/Cargo.toml
index 82a3871..5888e1a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "parse-zoneinfo"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["Djzin <djzin@users.noreply.github.com>"]
 description = "Parse zoneinfo files from the IANA database"
 keywords = ["date", "time", "timezone", "zone", "calendar"]

From 43d2752bd26f86a922c08da5a3885b5f882d1d34 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Sat, 21 Dec 2019 13:03:13 -0500
Subject: [PATCH 084/113] Silence a warning about bare trait objects

---
 src/table.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/table.rs b/src/table.rs
index 92b0f10..bee48c8 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -369,6 +369,7 @@ impl<'line> ErrorTrait for Error<'line> {
         "interpretation error"
     }
 
+    #[allow(bare_trait_objects)] // remove when we require edition 2018
     fn cause(&self) -> Option<&ErrorTrait> {
         None
     }

From 354a0b4cc0a62514bf9c965864b4a6246b01675f Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Sat, 21 Dec 2019 13:11:52 -0500
Subject: [PATCH 085/113] Run cargo fmt, check format in PRs

---
 .github/workflows/rust-test.yml |   2 +
 examples/benchmark.rs           |  12 +-
 src/lib.rs                      |   2 +-
 src/line.rs                     | 444 ++++++++++++++++++++------------
 src/structure.rs                |  46 ++--
 src/table.rs                    | 110 ++++----
 src/transitions.rs              | 287 ++++++++++++++++-----
 7 files changed, 589 insertions(+), 314 deletions(-)

diff --git a/.github/workflows/rust-test.yml b/.github/workflows/rust-test.yml
index 312cbfd..ddbdf92 100644
--- a/.github/workflows/rust-test.yml
+++ b/.github/workflows/rust-test.yml
@@ -9,6 +9,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v2
+    - name: Format
+      run: cargo fmt -- --check
     - name: Build
       run: cargo build --verbose
     - name: Run tests
diff --git a/examples/benchmark.rs b/examples/benchmark.rs
index bc80ed9..718f379 100644
--- a/examples/benchmark.rs
+++ b/examples/benchmark.rs
@@ -1,6 +1,6 @@
 extern crate parse_zoneinfo;
 
-use parse_zoneinfo::line::{LineParser, Line};
+use parse_zoneinfo::line::{Line, LineParser};
 use parse_zoneinfo::table::TableBuilder;
 
 // This function is needed until zoneinfo_parse handles comments correctly.
@@ -13,9 +13,11 @@ fn strip_comments(mut line: String) -> String {
 }
 
 fn main() {
-    let lines = std::fs::read_to_string("examples/asia").unwrap().lines().map(|line| {
-        strip_comments(line.to_string())
-    }).collect::<Vec<_>>();
+    let lines = std::fs::read_to_string("examples/asia")
+        .unwrap()
+        .lines()
+        .map(|line| strip_comments(line.to_string()))
+        .collect::<Vec<_>>();
 
     for _ in 0..100 {
         let parser = LineParser::new();
@@ -26,7 +28,7 @@ fn main() {
                 Line::Continuation(cont) => builder.add_continuation_line(cont).unwrap(),
                 Line::Rule(rule) => builder.add_rule_line(rule).unwrap(),
                 Line::Link(link) => builder.add_link_line(link).unwrap(),
-                Line::Space => {},
+                Line::Space => {}
             }
         }
         let _table = builder.build();
diff --git a/src/lib.rs b/src/lib.rs
index 6030c12..ae3f210 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,6 +1,6 @@
 extern crate regex;
 
 pub mod line;
+pub mod structure;
 pub mod table;
 pub mod transitions;
-pub mod structure;
diff --git a/src/line.rs b/src/line.rs
index 50ed148..a3e885b 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -3,7 +3,7 @@ use std::str::FromStr;
 #[allow(deprecated, unused_imports)]
 use std::ascii::AsciiExt;
 
-use regex::{Regex, Captures};
+use regex::{Captures, Regex};
 
 pub struct LineParser {
     rule_line: Regex,
@@ -35,7 +35,8 @@ pub enum Error {
 impl LineParser {
     pub fn new() -> Self {
         LineParser {
-            rule_line: Regex::new(r##"(?x) ^
+            rule_line: Regex::new(
+                r##"(?x) ^
                 Rule \s+
                 ( ?P<name>    \S+)  \s+
                 ( ?P<from>    \S+)  \s+
@@ -47,27 +48,39 @@ impl LineParser {
                 ( ?P<save>    \S+)  \s+
                 ( ?P<letters> \S+)  \s*
                 (\#.*)?
-            $ "##).unwrap(),
+            $ "##,
+            )
+            .unwrap(),
 
-            day_field: Regex::new(r##"(?x) ^
+            day_field: Regex::new(
+                r##"(?x) ^
                 ( ?P<weekday> \w+ )
                 ( ?P<sign>    [<>] = )
                 ( ?P<day>     \d+ )
-            $ "##).unwrap(),
+            $ "##,
+            )
+            .unwrap(),
 
-            hm_field: Regex::new(r##"(?x) ^
+            hm_field: Regex::new(
+                r##"(?x) ^
                 ( ?P<sign> -? )
                 ( ?P<hour> \d{1,2} ) : ( ?P<minute> \d{2} )
                 ( ?P<flag> [wsugz] )?
-            $ "##).unwrap(),
+            $ "##,
+            )
+            .unwrap(),
 
-            hms_field: Regex::new(r##"(?x) ^
+            hms_field: Regex::new(
+                r##"(?x) ^
                 ( ?P<sign> -? )
                 ( ?P<hour> \d{1,2} ) : ( ?P<minute> \d{2} ) : ( ?P<second> \d{2} )
                 ( ?P<flag> [wsugz] )?
-            $ "##).unwrap(),
+            $ "##,
+            )
+            .unwrap(),
 
-            zone_line: Regex::new(r##"(?x) ^
+            zone_line: Regex::new(
+                r##"(?x) ^
                 Zone \s+
                 ( ?P<name> [ A-Z a-z 0-9 / _ + - ]+ )  \s+
                 ( ?P<gmtoff>     \S+ )  \s+
@@ -78,9 +91,12 @@ impl LineParser {
                 ( ?P<day>        \S+ )? \s*
                 ( ?P<time>       \S+ )? \s*
                 (\#.*)?
-            $ "##).unwrap(),
+            $ "##,
+            )
+            .unwrap(),
 
-            continuation_line: Regex::new(r##"(?x) ^
+            continuation_line: Regex::new(
+                r##"(?x) ^
                 \s+
                 ( ?P<gmtoff>     \S+ )  \s+
                 ( ?P<rulessave>  \S+ )  \s+
@@ -90,19 +106,27 @@ impl LineParser {
                 ( ?P<day>        \S+ )? \s*
                 ( ?P<time>       \S+ )? \s*
                 (\#.*)?
-            $ "##).unwrap(),
+            $ "##,
+            )
+            .unwrap(),
 
-            link_line: Regex::new(r##"(?x) ^
+            link_line: Regex::new(
+                r##"(?x) ^
                 Link  \s+
                 ( ?P<target>  \S+ )  \s+
                 ( ?P<name>    \S+ )  \s*
                 (\#.*)?
-            $ "##).unwrap(),
+            $ "##,
+            )
+            .unwrap(),
 
-            empty_line: Regex::new(r##"(?x) ^
+            empty_line: Regex::new(
+                r##"(?x) ^
                 \s*
                 (\#.*)?
-            $"##).unwrap(),
+            $"##,
+            )
+            .unwrap(),
         }
     }
 }
@@ -123,8 +147,8 @@ impl FromStr for Year {
             "max" | "maximum" => Year::Maximum,
             year => match year.parse() {
                 Ok(year) => Year::Number(year),
-                Err(_)   => return Err(Error::FailedYearParse(input.to_string())),
-            }
+                Err(_) => return Err(Error::FailedYearParse(input.to_string())),
+            },
         })
     }
 }
@@ -148,19 +172,19 @@ pub enum Month {
 impl Month {
     fn length(self, is_leap: bool) -> i8 {
         match self {
-            Month::January             => 31,
+            Month::January => 31,
             Month::February if is_leap => 29,
-            Month::February            => 28,
-            Month::March               => 31,
-            Month::April               => 30,
-            Month::May                 => 31,
-            Month::June                => 30,
-            Month::July                => 31,
-            Month::August              => 31,
-            Month::September           => 30,
-            Month::October             => 31,
-            Month::November            => 30,
-            Month::December            => 31,
+            Month::February => 28,
+            Month::March => 31,
+            Month::April => 30,
+            Month::May => 31,
+            Month::June => 30,
+            Month::July => 31,
+            Month::August => 31,
+            Month::September => 30,
+            Month::October => 31,
+            Month::November => 30,
+            Month::December => 31,
         }
     }
 }
@@ -170,19 +194,19 @@ impl FromStr for Month {
 
     fn from_str(input: &str) -> Result<Month, Self::Err> {
         Ok(match &*input.to_ascii_lowercase() {
-            "jan" | "january"    => Month::January,
-            "feb" | "february"   => Month::February,
-            "mar" | "march"      => Month::March,
-            "apr" | "april"      => Month::April,
-            "may"                => Month::May,
-            "jun" | "june"       => Month::June,
-            "jul" | "july"       => Month::July,
-            "aug" | "august"     => Month::August,
-            "sep" | "september"  => Month::September,
-            "oct" | "october"    => Month::October,
-            "nov" | "november"   => Month::November,
-            "dec" | "december"   => Month::December,
-            other                => return Err(Error::FailedMonthParse(other.to_string())),
+            "jan" | "january" => Month::January,
+            "feb" | "february" => Month::February,
+            "mar" | "march" => Month::March,
+            "apr" | "april" => Month::April,
+            "may" => Month::May,
+            "jun" | "june" => Month::June,
+            "jul" | "july" => Month::July,
+            "aug" | "august" => Month::August,
+            "sep" | "september" => Month::September,
+            "oct" | "october" => Month::October,
+            "nov" | "november" => Month::November,
+            "dec" | "december" => Month::December,
+            other => return Err(Error::FailedMonthParse(other.to_string())),
         })
     }
 }
@@ -203,14 +227,14 @@ impl FromStr for Weekday {
 
     fn from_str(input: &str) -> Result<Weekday, Self::Err> {
         Ok(match &*input.to_ascii_lowercase() {
-            "mon" | "monday"     => Weekday::Monday,
-            "tue" | "tuesday"    => Weekday::Tuesday,
-            "wed" | "wednesday"  => Weekday::Wednesday,
-            "thu" | "thursday"   => Weekday::Thursday,
-            "fri" | "friday"     => Weekday::Friday,
-            "sat" | "saturday"   => Weekday::Saturday,
-            "sun" | "sunday"     => Weekday::Sunday,
-            other                => return Err(Error::FailedWeekdayParse(other.to_string())),
+            "mon" | "monday" => Weekday::Monday,
+            "tue" | "tuesday" => Weekday::Tuesday,
+            "wed" | "wednesday" => Weekday::Wednesday,
+            "thu" | "thursday" => Weekday::Thursday,
+            "fri" | "friday" => Weekday::Friday,
+            "sat" | "saturday" => Weekday::Saturday,
+            "sun" | "sunday" => Weekday::Sunday,
+            other => return Err(Error::FailedWeekdayParse(other.to_string())),
         })
     }
 }
@@ -220,16 +244,16 @@ pub enum DaySpec {
     Ordinal(i8),
     Last(Weekday),
     LastOnOrBefore(Weekday, i8),
-    FirstOnOrAfter(Weekday, i8)
+    FirstOnOrAfter(Weekday, i8),
 }
 
 impl Weekday {
     fn calculate(year: i64, month: Month, day: i8) -> Weekday {
         let m = month as i64;
-        let y = if m < 3 { year - 1} else { year };
+        let y = if m < 3 { year - 1 } else { year };
         let d = day as i64;
         const T: [i64; 12] = [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4];
-        match (y + y/4 - y/100 + y/400 + T[m as usize-1] + d) % 7 {
+        match (y + y / 4 - y / 100 + y / 400 + T[m as usize - 1] + d) % 7 {
             0 => Weekday::Sunday,
             1 => Weekday::Monday,
             2 => Weekday::Tuesday,
@@ -237,7 +261,7 @@ impl Weekday {
             4 => Weekday::Thursday,
             5 => Weekday::Friday,
             6 => Weekday::Saturday,
-            _ => panic!("why is negative modulus designed so?")
+            _ => panic!("why is negative modulus designed so?"),
         }
     }
 }
@@ -245,19 +269,40 @@ impl Weekday {
 #[cfg(test)]
 #[test]
 fn weekdays() {
-    assert_eq!(Weekday::calculate(1970, Month::January, 1), Weekday::Thursday);
-    assert_eq!(Weekday::calculate(2017, Month::February, 11), Weekday::Saturday);
+    assert_eq!(
+        Weekday::calculate(1970, Month::January, 1),
+        Weekday::Thursday
+    );
+    assert_eq!(
+        Weekday::calculate(2017, Month::February, 11),
+        Weekday::Saturday
+    );
     assert_eq!(Weekday::calculate(1890, Month::March, 2), Weekday::Sunday);
     assert_eq!(Weekday::calculate(2100, Month::April, 20), Weekday::Tuesday);
     assert_eq!(Weekday::calculate(2009, Month::May, 31), Weekday::Sunday);
     assert_eq!(Weekday::calculate(2001, Month::June, 9), Weekday::Saturday);
     assert_eq!(Weekday::calculate(1995, Month::July, 21), Weekday::Friday);
     assert_eq!(Weekday::calculate(1982, Month::August, 8), Weekday::Sunday);
-    assert_eq!(Weekday::calculate(1962, Month::September, 6), Weekday::Thursday);
-    assert_eq!(Weekday::calculate(1899, Month::October, 14), Weekday::Saturday);
-    assert_eq!(Weekday::calculate(2016, Month::November, 18), Weekday::Friday);
-    assert_eq!(Weekday::calculate(2010, Month::December, 19), Weekday::Sunday);
-    assert_eq!(Weekday::calculate(2016, Month::February, 29), Weekday::Monday);
+    assert_eq!(
+        Weekday::calculate(1962, Month::September, 6),
+        Weekday::Thursday
+    );
+    assert_eq!(
+        Weekday::calculate(1899, Month::October, 14),
+        Weekday::Saturday
+    );
+    assert_eq!(
+        Weekday::calculate(2016, Month::November, 18),
+        Weekday::Friday
+    );
+    assert_eq!(
+        Weekday::calculate(2010, Month::December, 19),
+        Weekday::Sunday
+    );
+    assert_eq!(
+        Weekday::calculate(2016, Month::February, 29),
+        Weekday::Monday
+    );
 }
 
 fn is_leap(year: i64) -> bool {
@@ -295,12 +340,17 @@ impl DaySpec {
 
         match *self {
             DaySpec::Ordinal(day) => day,
-            DaySpec::Last(weekday) => (1..length+1).rev()
-                .find(|&day| Weekday::calculate(year, month, day) == weekday).unwrap(),
-            DaySpec::LastOnOrBefore(weekday, day) => (1..day+1).rev()
-                .find(|&day| Weekday::calculate(year, month, day) == weekday).unwrap(),
-            DaySpec::FirstOnOrAfter(weekday, day) => (day..length+1)
-                .find(|&day| Weekday::calculate(year, month, day) == weekday).unwrap(),
+            DaySpec::Last(weekday) => (1..length + 1)
+                .rev()
+                .find(|&day| Weekday::calculate(year, month, day) == weekday)
+                .unwrap(),
+            DaySpec::LastOnOrBefore(weekday, day) => (1..day + 1)
+                .rev()
+                .find(|&day| Weekday::calculate(year, month, day) == weekday)
+                .unwrap(),
+            DaySpec::FirstOnOrAfter(weekday, day) => (day..length + 1)
+                .find(|&day| Weekday::calculate(year, month, day) == weekday)
+                .unwrap(),
         }
     }
 }
@@ -386,7 +436,6 @@ pub enum ChangeTime {
 
 impl ChangeTime {
     pub fn to_timestamp(&self) -> i64 {
-
         fn seconds_in_year(year: i64) -> i64 {
             if is_leap(year) {
                 366 * 24 * 60 * 60
@@ -403,7 +452,14 @@ impl ChangeTime {
             }
         }
 
-        fn time_to_timestamp(year: i64, month: i8, day: i8, hour: i8, minute: i8, second: i8) -> i64 {
+        fn time_to_timestamp(
+            year: i64,
+            month: i8,
+            day: i8,
+            hour: i8,
+            minute: i8,
+            second: i8,
+        ) -> i64 {
             const MONTHS_NON_LEAP: [i64; 12] = [
                 0,
                 31,
@@ -416,7 +472,7 @@ impl ChangeTime {
                 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
                 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
                 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
-                31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30
+                31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
             ];
             const MONTHS_LEAP: [i64; 12] = [
                 0,
@@ -430,10 +486,16 @@ impl ChangeTime {
                 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31,
                 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
                 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
-                31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30
+                31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
             ];
             seconds_until_start_of_year(year)
-                + 60 * 60 * 24 * if is_leap(year) { MONTHS_LEAP[month as usize - 1] } else { MONTHS_NON_LEAP[month as usize - 1] }
+                + 60 * 60
+                    * 24
+                    * if is_leap(year) {
+                        MONTHS_LEAP[month as usize - 1]
+                    } else {
+                        MONTHS_NON_LEAP[month as usize - 1]
+                    }
                 + 60 * 60 * 24 * (day as i64 - 1)
                 + 60 * 60 * hour as i64
                 + 60 * minute as i64
@@ -441,14 +503,22 @@ impl ChangeTime {
         }
 
         match *self {
-            ChangeTime::UntilYear(Year::Number(y))             => time_to_timestamp(y, 1,                             1, 0, 0,   0),
-            ChangeTime::UntilMonth(Year::Number(y), m)         => time_to_timestamp(y, m as i8,                       1, 0, 0,   0),
-            ChangeTime::UntilDay(Year::Number(y), m, d)        => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), 0, 0,   0),
+            ChangeTime::UntilYear(Year::Number(y)) => time_to_timestamp(y, 1, 1, 0, 0, 0),
+            ChangeTime::UntilMonth(Year::Number(y), m) => time_to_timestamp(y, m as i8, 1, 0, 0, 0),
+            ChangeTime::UntilDay(Year::Number(y), m, d) => {
+                time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), 0, 0, 0)
+            }
             ChangeTime::UntilTime(Year::Number(y), m, d, time) => match time.0 {
-                TimeSpec::Zero                                 => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), 0, 0,   0),
-                TimeSpec::Hours(h)                             => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, 0,   0),
-                TimeSpec::HoursMinutes(h, min)                 => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, min, 0),
-                TimeSpec::HoursMinutesSeconds(h, min, s)       => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, min, s),
+                TimeSpec::Zero => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), 0, 0, 0),
+                TimeSpec::Hours(h) => {
+                    time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, 0, 0)
+                }
+                TimeSpec::HoursMinutes(h, min) => {
+                    time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, min, 0)
+                }
+                TimeSpec::HoursMinutesSeconds(h, min, s) => {
+                    time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, min, s)
+                }
             },
             _ => unreachable!(),
         }
@@ -456,11 +526,11 @@ impl ChangeTime {
 
     pub fn year(&self) -> i64 {
         match *self {
-            ChangeTime::UntilYear(Year::Number(y))      => y,
+            ChangeTime::UntilYear(Year::Number(y)) => y,
             ChangeTime::UntilMonth(Year::Number(y), ..) => y,
-            ChangeTime::UntilDay(Year::Number(y), ..)   => y,
-            ChangeTime::UntilTime(Year::Number(y), ..)  => y,
-            _ => unreachable!()
+            ChangeTime::UntilDay(Year::Number(y), ..) => y,
+            ChangeTime::UntilTime(Year::Number(y), ..) => y,
+            _ => unreachable!(),
         }
     }
 }
@@ -474,8 +544,12 @@ fn to_timestamp() {
     assert_eq!(time.to_timestamp(), 1451606400);
     let time = ChangeTime::UntilYear(Year::Number(1900));
     assert_eq!(time.to_timestamp(), -2208988800);
-    let time = ChangeTime::UntilTime(Year::Number(2000), Month::February, DaySpec::Last(Weekday::Sunday),
-        TimeSpecAndType(TimeSpec::Hours(9), TimeType::Wall));
+    let time = ChangeTime::UntilTime(
+        Year::Number(2000),
+        Month::February,
+        DaySpec::Last(Weekday::Sunday),
+        TimeSpecAndType(TimeSpec::Hours(9), TimeType::Wall),
+    );
     assert_eq!(time.to_timestamp(), 951642000);
 }
 
@@ -529,10 +603,10 @@ pub enum Line<'a> {
 
 fn parse_time_type(c: &str) -> Option<TimeType> {
     Some(match c {
-        "w"             => TimeType::Wall,
-        "s"             => TimeType::Standard,
+        "w" => TimeType::Wall,
+        "s" => TimeType::Standard,
         "u" | "g" | "z" => TimeType::UTC,
-         _              => return None,
+        _ => return None,
     })
 }
 
@@ -540,28 +614,46 @@ impl LineParser {
     fn parse_timespec_and_type(&self, input: &str) -> Result<TimeSpecAndType, Error> {
         if input == "-" {
             Ok(TimeSpecAndType(TimeSpec::Zero, TimeType::Wall))
-        }
-        else if input.chars().all(|c| c == '-' || c.is_digit(10)) {
-            Ok(TimeSpecAndType(TimeSpec::Hours(input.parse().unwrap()), TimeType::Wall))
-        }
-        else if let Some(caps) = self.hm_field.captures(input) {
-            let sign   : i8 = if caps.name("sign").unwrap().as_str() == "-" { -1 } else { 1 };
-            let hour   : i8 = caps.name("hour").unwrap().as_str().parse().unwrap();
-            let minute : i8 = caps.name("minute").unwrap().as_str().parse().unwrap();
-            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c.as_str()[0..1]))
-                                          .unwrap_or(TimeType::Wall);
-
-            Ok(TimeSpecAndType(TimeSpec::HoursMinutes(hour * sign, minute * sign), flag))
-        }
-        else if let Some(caps) = self.hms_field.captures(input) {
-            let sign   : i8 = if caps.name("sign").unwrap().as_str() == "-" { -1 } else { 1 };
-            let hour   : i8 = caps.name("hour").unwrap().as_str().parse().unwrap();
-            let minute : i8 = caps.name("minute").unwrap().as_str().parse().unwrap();
-            let second : i8 = caps.name("second").unwrap().as_str().parse().unwrap();
-            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c.as_str()[0..1]))
-                                          .unwrap_or(TimeType::Wall);
-
-            Ok(TimeSpecAndType(TimeSpec::HoursMinutesSeconds(hour * sign, minute * sign, second * sign), flag))
+        } else if input.chars().all(|c| c == '-' || c.is_digit(10)) {
+            Ok(TimeSpecAndType(
+                TimeSpec::Hours(input.parse().unwrap()),
+                TimeType::Wall,
+            ))
+        } else if let Some(caps) = self.hm_field.captures(input) {
+            let sign: i8 = if caps.name("sign").unwrap().as_str() == "-" {
+                -1
+            } else {
+                1
+            };
+            let hour: i8 = caps.name("hour").unwrap().as_str().parse().unwrap();
+            let minute: i8 = caps.name("minute").unwrap().as_str().parse().unwrap();
+            let flag = caps
+                .name("flag")
+                .and_then(|c| parse_time_type(&c.as_str()[0..1]))
+                .unwrap_or(TimeType::Wall);
+
+            Ok(TimeSpecAndType(
+                TimeSpec::HoursMinutes(hour * sign, minute * sign),
+                flag,
+            ))
+        } else if let Some(caps) = self.hms_field.captures(input) {
+            let sign: i8 = if caps.name("sign").unwrap().as_str() == "-" {
+                -1
+            } else {
+                1
+            };
+            let hour: i8 = caps.name("hour").unwrap().as_str().parse().unwrap();
+            let minute: i8 = caps.name("minute").unwrap().as_str().parse().unwrap();
+            let second: i8 = caps.name("second").unwrap().as_str().parse().unwrap();
+            let flag = caps
+                .name("flag")
+                .and_then(|c| parse_time_type(&c.as_str()[0..1]))
+                .unwrap_or(TimeType::Wall);
+
+            Ok(TimeSpecAndType(
+                TimeSpec::HoursMinutesSeconds(hour * sign, minute * sign, second * sign),
+                flag,
+            ))
         } else {
             Err(Error::InvalidTimeSpecAndType(input.to_string()))
         }
@@ -583,12 +675,12 @@ impl LineParser {
             Ok(DaySpec::Last(weekday))
         } else if let Some(caps) = self.day_field.captures(input) {
             let weekday = caps.name("weekday").unwrap().as_str().parse().unwrap();
-            let day     = caps.name("day").unwrap().as_str().parse().unwrap();
+            let day = caps.name("day").unwrap().as_str().parse().unwrap();
 
             match caps.name("sign").unwrap().as_str() {
                 "<=" => Ok(DaySpec::LastOnOrBefore(weekday, day)),
                 ">=" => Ok(DaySpec::FirstOnOrAfter(weekday, day)),
-                 _   => unreachable!("The regex only matches one of those two!"),
+                _ => unreachable!("The regex only matches one of those two!"),
             }
         } else {
             Err(Error::InvalidDaySpec(input.to_string()))
@@ -597,14 +689,14 @@ impl LineParser {
 
     fn parse_rule<'a>(&self, input: &'a str) -> Result<Rule<'a>, Error> {
         if let Some(caps) = self.rule_line.captures(input) {
-            let name      = caps.name("name").unwrap().as_str();
+            let name = caps.name("name").unwrap().as_str();
             let from_year = caps.name("from").unwrap().as_str().parse()?;
 
             // The end year can be ‘only’ to indicate that this rule only
             // takes place on that year.
             let to_year = match caps.name("to").unwrap().as_str() {
-                "only"  => None,
-                to      => Some(to.parse()?),
+                "only" => None,
+                to => Some(to.parse()?),
             };
 
             // According to the spec, the only value inside the ‘type’ column
@@ -612,28 +704,28 @@ impl LineParser {
             // for compatibility with old versions that used to contain year
             // types.) Sometimes “‐”, a Unicode hyphen, is used as well.
             let t = caps.name("type").unwrap().as_str();
-            if t != "-" && t != "\u{2010}"  {
+            if t != "-" && t != "\u{2010}" {
                 return Err(Error::TypeColumnContainedNonHyphen(t.to_string()));
             }
 
-            let month        = caps.name("in").unwrap().as_str().parse()?;
-            let day          = self.parse_dayspec(caps.name("on").unwrap().as_str())?;
-            let time         = self.parse_timespec_and_type(caps.name("at").unwrap().as_str())?;
-            let time_to_add  = self.parse_timespec(caps.name("save").unwrap().as_str())?;
-            let letters      = match caps.name("letters").unwrap().as_str() {
-                "-"  => None,
-                l    => Some(l),
+            let month = caps.name("in").unwrap().as_str().parse()?;
+            let day = self.parse_dayspec(caps.name("on").unwrap().as_str())?;
+            let time = self.parse_timespec_and_type(caps.name("at").unwrap().as_str())?;
+            let time_to_add = self.parse_timespec(caps.name("save").unwrap().as_str())?;
+            let letters = match caps.name("letters").unwrap().as_str() {
+                "-" => None,
+                l => Some(l),
             };
 
             Ok(Rule {
-                name:         name,
-                from_year:    from_year,
-                to_year:      to_year,
-                month:        month,
-                day:          day,
-                time:         time,
-                time_to_add:  time_to_add,
-                letters:      letters,
+                name: name,
+                from_year: from_year,
+                to_year: to_year,
+                month: month,
+                day: day,
+                time: time,
+                time_to_add: time_to_add,
+                letters: letters,
             })
         } else {
             Err(Error::NotParsedAsRuleLine)
@@ -643,7 +735,10 @@ impl LineParser {
     fn saving_from_str<'a>(&self, input: &'a str) -> Result<Saving<'a>, Error> {
         if input == "-" {
             Ok(Saving::NoSaving)
-        } else if input.chars().all(|c| c == '-' || c == '_' || c.is_alphabetic()) {
+        } else if input
+            .chars()
+            .all(|c| c == '-' || c == '_' || c.is_alphabetic())
+        {
             Ok(Saving::Multiple(input))
         } else if self.hm_field.is_match(input) {
             let time = self.parse_timespec(input)?;
@@ -658,20 +753,37 @@ impl LineParser {
         let saving = self.saving_from_str(caps.name("rulessave").unwrap().as_str())?;
         let format = caps.name("format").unwrap().as_str();
 
-        let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
-            (Some(y), Some(m), Some(d), Some(t)) => Some(ChangeTime::UntilTime  (y.as_str().parse()?, m.as_str().parse()?, self.parse_dayspec(d.as_str())?, self.parse_timespec_and_type(t.as_str())?)),
-            (Some(y), Some(m), Some(d), _      ) => Some(ChangeTime::UntilDay   (y.as_str().parse()?, m.as_str().parse()?, self.parse_dayspec(d.as_str())?)),
-            (Some(y), Some(m), _      , _      ) => Some(ChangeTime::UntilMonth (y.as_str().parse()?, m.as_str().parse()?)),
-            (Some(y), _      , _      , _      ) => Some(ChangeTime::UntilYear  (y.as_str().parse()?)),
-            (None   , None   , None   , None   ) => None,
-            _                                    => unreachable!("Out-of-order capturing groups!"),
+        let time = match (
+            caps.name("year"),
+            caps.name("month"),
+            caps.name("day"),
+            caps.name("time"),
+        ) {
+            (Some(y), Some(m), Some(d), Some(t)) => Some(ChangeTime::UntilTime(
+                y.as_str().parse()?,
+                m.as_str().parse()?,
+                self.parse_dayspec(d.as_str())?,
+                self.parse_timespec_and_type(t.as_str())?,
+            )),
+            (Some(y), Some(m), Some(d), _) => Some(ChangeTime::UntilDay(
+                y.as_str().parse()?,
+                m.as_str().parse()?,
+                self.parse_dayspec(d.as_str())?,
+            )),
+            (Some(y), Some(m), _, _) => Some(ChangeTime::UntilMonth(
+                y.as_str().parse()?,
+                m.as_str().parse()?,
+            )),
+            (Some(y), _, _, _) => Some(ChangeTime::UntilYear(y.as_str().parse()?)),
+            (None, None, None, None) => None,
+            _ => unreachable!("Out-of-order capturing groups!"),
         };
 
         Ok(ZoneInfo {
-            utc_offset:  utc_offset,
-            saving:      saving,
-            format:      format,
-            time:        time,
+            utc_offset: utc_offset,
+            saving: saving,
+            format: format,
+            time: time,
         })
     }
 
@@ -690,40 +802,42 @@ impl LineParser {
 
     fn parse_link<'a>(&self, input: &'a str) -> Result<Link<'a>, Error> {
         if let Some(caps) = self.link_line.captures(input) {
-            let target  = caps.name("target").unwrap().as_str();
-            let name    = caps.name("name").unwrap().as_str();
-            Ok(Link { existing: target, new: name })
-        }
-        else {
+            let target = caps.name("target").unwrap().as_str();
+            let name = caps.name("name").unwrap().as_str();
+            Ok(Link {
+                existing: target,
+                new: name,
+            })
+        } else {
             Err(Error::NotParsedAsLinkLine)
         }
     }
 
     pub fn parse_str<'a>(&self, input: &'a str) -> Result<Line<'a>, Error> {
         if self.empty_line.is_match(input) {
-            return Ok(Line::Space)
+            return Ok(Line::Space);
         }
 
         match self.parse_zone(input) {
-            Err(Error::NotParsedAsZoneLine) => {},
+            Err(Error::NotParsedAsZoneLine) => {}
             result => return result.map(Line::Zone),
         }
 
         match self.continuation_line.captures(input) {
-            None => {},
+            None => {}
             Some(caps) => return self.zoneinfo_from_captures(caps).map(Line::Continuation),
         }
 
         match self.parse_rule(input) {
-            Err(Error::NotParsedAsRuleLine) => {},
+            Err(Error::NotParsedAsRuleLine) => {}
             result => return result.map(Line::Rule),
         }
 
         match self.parse_link(input) {
-            Err(Error::NotParsedAsLinkLine) => {},
+            Err(Error::NotParsedAsLinkLine) => {}
             result => return result.map(Line::Link),
         }
-        
+
         Err(Error::InvalidLineType(input.to_string()))
     }
 }
@@ -820,15 +934,22 @@ mod tests {
         static LINE: &'static str = "Zone    Europe/London   -0:01:15 -  LMT 1847 Dec  1  0:00s";
         let parser = LineParser::new();
         let zone = parser.parse_zone(LINE).unwrap();
-        assert_eq!(zone.info.utc_offset, TimeSpec::HoursMinutesSeconds(0, -1, -15));
+        assert_eq!(
+            zone.info.utc_offset,
+            TimeSpec::HoursMinutesSeconds(0, -1, -15)
+        );
     }
 
     #[test]
     fn negative_offsets_2() {
-        static LINE: &'static str = "Zone        Europe/Madrid   -0:14:44 -      LMT     1901 Jan  1  0:00s";
+        static LINE: &'static str =
+            "Zone        Europe/Madrid   -0:14:44 -      LMT     1901 Jan  1  0:00s";
         let parser = LineParser::new();
         let zone = parser.parse_zone(LINE).unwrap();
-        assert_eq!(zone.info.utc_offset, TimeSpec::HoursMinutesSeconds(0, -14, -44));
+        assert_eq!(
+            zone.info.utc_offset,
+            TimeSpec::HoursMinutesSeconds(0, -14, -44)
+        );
     }
 
     #[test]
@@ -836,7 +957,10 @@ mod tests {
         static LINE: &'static str = "Zone America/Danmarkshavn -1:14:40 -    LMT 1916 Jul 28";
         let parser = LineParser::new();
         let zone = parser.parse_zone(LINE).unwrap();
-        assert_eq!(zone.info.utc_offset, TimeSpec::HoursMinutesSeconds(-1, -14, -40));
+        assert_eq!(
+            zone.info.utc_offset,
+            TimeSpec::HoursMinutesSeconds(-1, -14, -40)
+        );
     }
 
     test!(link: "Link  Europe/Istanbul  Asia/Istanbul" => Ok(Line::Link(Link {
diff --git a/src/structure.rs b/src/structure.rs
index 73ce7a6..3717017 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -34,10 +34,8 @@ use std::collections::{BTreeMap, BTreeSet};
 
 use table::Table;
 
-
 /// Trait to put the `structure` method on Tables.
 pub trait Structure {
-
     /// Returns an iterator over the structure of this table.
     fn structure(&self) -> TableStructure;
 }
@@ -47,20 +45,19 @@ impl Structure for Table {
         let mut mappings = BTreeMap::new();
 
         for key in self.zonesets.keys().chain(self.links.keys()) {
-
             // Extract the name from the *last* slash. So
             // `America/Kentucky/Louisville` is split into
             // `America/Kentucky` and `Louisville` components.
             let last_slash = match key.rfind('/') {
                 Some(pos) => pos,
-                None      => continue,
+                None => continue,
             };
 
             // Split the string around the slash, which gets removed.
-            let parent = &key[.. last_slash];
+            let parent = &key[..last_slash];
             {
                 let set = mappings.entry(parent).or_insert_with(BTreeSet::new);
-                set.insert(Child::TimeZone(&key[last_slash + 1 ..]));
+                set.insert(Child::TimeZone(&key[last_slash + 1..]));
             }
 
             // If the *parent* name still has a slash in it, then this is
@@ -68,9 +65,9 @@ impl Structure for Table {
             // need to make sure that `America` now has a `Kentucky`
             // child, too.
             if let Some(first_slash) = parent.find('/') {
-                let grandparent = &parent[.. first_slash];
+                let grandparent = &parent[..first_slash];
                 let set = mappings.entry(grandparent).or_insert_with(BTreeSet::new);
-                set.insert(Child::Submodule(&parent[first_slash + 1 ..]));
+                set.insert(Child::Submodule(&parent[first_slash + 1..]));
             }
         }
 
@@ -78,7 +75,6 @@ impl Structure for Table {
     }
 }
 
-
 /// The structure of a set of time zone names.
 #[derive(PartialEq, Debug)]
 pub struct TableStructure<'table> {
@@ -90,7 +86,6 @@ impl<'table> IntoIterator for TableStructure<'table> {
     type IntoIter = Iter<'table>;
 
     fn into_iter(self) -> Self::IntoIter {
-
         // It’s necessary to sort the keys before producing them, to
         // ensure that (for example) `America` is produced before
         // `America/Kentucky`.
@@ -118,7 +113,7 @@ impl<'table> Iterator for Iter<'table> {
         loop {
             let key = match self.keys.pop() {
                 Some(k) => k,
-                None    => return None,
+                None => return None,
             };
 
             // Move the strings out into an (automatically-sorted) vector.
@@ -135,7 +130,6 @@ impl<'table> Iterator for Iter<'table> {
 /// An entry returned from a `TableStructure` iterator.
 #[derive(PartialEq, Debug)]
 pub struct TableStructureEntry<'table> {
-
     /// This entry’s name, which *can* still include slashes.
     pub name: &'table str,
 
@@ -150,7 +144,6 @@ pub struct TableStructureEntry<'table> {
 /// before the files in them can be written.
 #[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Copy, Clone)]
 pub enum Child<'table> {
-
     /// A module containing **only** submodules, no time zones.
     Submodule(&'table str),
 
@@ -158,7 +151,6 @@ pub enum Child<'table> {
     TimeZone(&'table str),
 }
 
-
 #[cfg(test)]
 #[allow(unused_results)]
 mod test {
@@ -189,7 +181,13 @@ mod test {
         table.zonesets.insert("a/b".to_owned(), Vec::new());
 
         let mut structure = table.structure().into_iter();
-        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(), children: vec![ Child::TimeZone("b") ] }));
+        assert_eq!(
+            structure.next(),
+            Some(TableStructureEntry {
+                name: &"a".to_owned(),
+                children: vec![Child::TimeZone("b")]
+            })
+        );
         assert_eq!(structure.next(), None);
     }
 
@@ -198,11 +196,23 @@ mod test {
         let mut table = Table::default();
         table.zonesets.insert("a/b/c".to_owned(), Vec::new());
         table.zonesets.insert("a/b/d".to_owned(), Vec::new());
-        table.zonesets.insert("a/e".to_owned(),   Vec::new());
+        table.zonesets.insert("a/e".to_owned(), Vec::new());
 
         let mut structure = table.structure().into_iter();
-        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a".to_owned(),   children: vec![ Child::Submodule("b"), Child::TimeZone("e") ] }));
-        assert_eq!(structure.next(), Some(TableStructureEntry { name: &"a/b".to_owned(), children: vec![ Child::TimeZone("c"),  Child::TimeZone("d") ] }));
+        assert_eq!(
+            structure.next(),
+            Some(TableStructureEntry {
+                name: &"a".to_owned(),
+                children: vec![Child::Submodule("b"), Child::TimeZone("e")]
+            })
+        );
+        assert_eq!(
+            structure.next(),
+            Some(TableStructureEntry {
+                name: &"a/b".to_owned(),
+                children: vec![Child::TimeZone("c"), Child::TimeZone("d")]
+            })
+        );
         assert_eq!(structure.next(), None);
     }
 }
diff --git a/src/table.rs b/src/table.rs
index bee48c8..95e359b 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -1,13 +1,12 @@
-use std::collections::hash_map::{HashMap, Entry};
+use std::collections::hash_map::{Entry, HashMap};
 use std::error::Error as ErrorTrait;
 use std::fmt;
 
-use line::{self, Year, Month, DaySpec, ChangeTime, TimeType};
+use line::{self, ChangeTime, DaySpec, Month, TimeType, Year};
 
 /// A **table** of all the data in one or more zoneinfo files.
 #[derive(PartialEq, Debug, Default)]
 pub struct Table {
-
     /// Mapping of ruleset names to rulesets.
     pub rulesets: HashMap<String, Vec<RuleInfo>>,
 
@@ -18,26 +17,21 @@ pub struct Table {
     pub links: HashMap<String, String>,
 }
 
-
 impl Table {
-
     /// Tries to find the zoneset with the given name by looking it up in
     /// either the zonesets map or the links map.
     pub fn get_zoneset(&self, zone_name: &str) -> Option<&[ZoneInfo]> {
         if self.zonesets.contains_key(zone_name) {
             Some(&*self.zonesets[zone_name])
-        }
-        else if self.links.contains_key(zone_name) {
+        } else if self.links.contains_key(zone_name) {
             let target = &self.links[zone_name];
             Some(&*self.zonesets[&*target])
-        }
-        else {
+        } else {
             None
         }
     }
 }
 
-
 /// An owned rule definition line.
 ///
 /// This mimics the `Rule` struct in the `line` module, only its uses owned
@@ -45,7 +39,6 @@ impl Table {
 /// applied to it.
 #[derive(PartialEq, Debug)]
 pub struct RuleInfo {
-
     /// The year that this rule *starts* applying.
     pub from_year: Year,
 
@@ -76,38 +69,36 @@ pub struct RuleInfo {
 impl<'line> From<line::Rule<'line>> for RuleInfo {
     fn from(info: line::Rule) -> RuleInfo {
         RuleInfo {
-            from_year:    info.from_year,
-            to_year:      info.to_year,
-            month:        info.month,
-            day:          info.day,
-            time:         info.time.0.as_seconds(),
-            time_type:    info.time.1,
-            time_to_add:  info.time_to_add.as_seconds(),
-            letters:      info.letters.map(str::to_owned),
+            from_year: info.from_year,
+            to_year: info.to_year,
+            month: info.month,
+            day: info.day,
+            time: info.time.0.as_seconds(),
+            time_type: info.time.1,
+            time_to_add: info.time_to_add.as_seconds(),
+            letters: info.letters.map(str::to_owned),
         }
     }
 }
 
 impl RuleInfo {
-
     /// Returns whether this rule is in effect during the given year.
     pub fn applies_to_year(&self, year: i64) -> bool {
         use line::Year::*;
 
         match (self.from_year, self.to_year) {
-            (Number(from), None)             => year == from,
-            (Number(from), Some(Maximum))    => year >= from,
+            (Number(from), None) => year == from,
+            (Number(from), Some(Maximum)) => year >= from,
             (Number(from), Some(Number(to))) => year >= from && year <= to,
             _ => unreachable!(),
         }
     }
 
     pub fn absolute_datetime(&self, year: i64, utc_offset: i64, dst_offset: i64) -> i64 {
-
         let offset = match self.time_type {
-            TimeType::UTC       => 0,
-            TimeType::Standard  => utc_offset,
-            TimeType::Wall      => utc_offset + dst_offset,
+            TimeType::UTC => 0,
+            TimeType::Standard => utc_offset,
+            TimeType::Wall => utc_offset + dst_offset,
         };
 
         let changetime = ChangeTime::UntilDay(Year::Number(year), self.month, self.day);
@@ -115,7 +106,6 @@ impl RuleInfo {
     }
 }
 
-
 /// An owned zone definition line.
 ///
 /// This struct mimics the `ZoneInfo` struct in the `line` module, *not* the
@@ -125,7 +115,6 @@ impl RuleInfo {
 /// slices.
 #[derive(PartialEq, Debug)]
 pub struct ZoneInfo {
-
     /// The number of seconds that need to be added to UTC to get the
     /// standard time in this zone.
     pub offset: i64,
@@ -147,17 +136,16 @@ impl<'line> From<line::ZoneInfo<'line>> for ZoneInfo {
         ZoneInfo {
             offset: info.utc_offset.as_seconds(),
             saving: match info.saving {
-                line::Saving::NoSaving     => Saving::NoSaving,
-                line::Saving::Multiple(s)  => Saving::Multiple(s.to_owned()),
-                line::Saving::OneOff(t)    => Saving::OneOff(t.as_seconds()),
+                line::Saving::NoSaving => Saving::NoSaving,
+                line::Saving::Multiple(s) => Saving::Multiple(s.to_owned()),
+                line::Saving::OneOff(t) => Saving::OneOff(t.as_seconds()),
             },
-            format:   Format::new(info.format),
+            format: Format::new(info.format),
             end_time: info.time,
         }
     }
 }
 
-
 /// The amount of daylight saving time (DST) to apply to this timespan. This
 /// is a special type for a certain field in a zone line, which can hold
 /// different types of value.
@@ -165,7 +153,6 @@ impl<'line> From<line::ZoneInfo<'line>> for ZoneInfo {
 /// This is the owned version of the `Saving` type in the `line` module.
 #[derive(PartialEq, Debug)]
 pub enum Saving {
-
     /// Just stick to the base offset.
     NoSaving,
 
@@ -179,11 +166,9 @@ pub enum Saving {
     Multiple(String),
 }
 
-
 /// The format string to generate a time zone abbreviation from.
 #[derive(PartialEq, Debug, Clone)]
 pub enum Format {
-
     /// A constant format, which remains the same throughout both standard
     /// and DST timespans.
     Constant(String),
@@ -191,7 +176,6 @@ pub enum Format {
     /// An alternate format, such as “PST/PDT”, which changes between
     /// standard and DST timespans.
     Alternate {
-
         /// Abbreviation to use during Standard Time.
         standard: String,
 
@@ -205,21 +189,18 @@ pub enum Format {
 }
 
 impl Format {
-
     /// Convert the template into one of the `Format` variants. This can’t
     /// fail, as any syntax that doesn’t match one of the two formats will
     /// just be a ‘constant’ format.
     pub fn new(template: &str) -> Format {
         if let Some(pos) = template.find('/') {
             Format::Alternate {
-                standard:  template[.. pos].to_owned(),
-                dst:       template[pos + 1 ..].to_owned(),
+                standard: template[..pos].to_owned(),
+                dst: template[pos + 1..].to_owned(),
             }
-        }
-        else if template.contains("%s") {
+        } else if template.contains("%s") {
             Format::Placeholder(template.to_owned())
-        }
-        else {
+        } else {
             Format::Constant(template.to_owned())
         }
     }
@@ -227,7 +208,7 @@ impl Format {
     pub fn format(&self, dst_offset: i64, letters: Option<&String>) -> String {
         let letters = match letters {
             Some(l) => &**l,
-            None    => "",
+            None => "",
         };
 
         match *self {
@@ -241,18 +222,15 @@ impl Format {
     pub fn format_constant(&self) -> String {
         if let Format::Constant(ref s) = *self {
             s.clone()
-        }
-        else {
+        } else {
             panic!("Expected a constant formatting string");
         }
     }
 }
 
-
 /// A builder for `Table` values based on various line definitions.
 #[derive(PartialEq, Debug)]
 pub struct TableBuilder {
-
     /// The table that’s being built up.
     table: Table,
 
@@ -263,7 +241,6 @@ pub struct TableBuilder {
 }
 
 impl TableBuilder {
-
     /// Creates a new builder with an empty table.
     pub fn new() -> TableBuilder {
         TableBuilder {
@@ -276,7 +253,10 @@ impl TableBuilder {
     ///
     /// Returns an error if there’s already a zone with the same name, or the
     /// zone refers to a ruleset that hasn’t been defined yet.
-    pub fn add_zone_line<'line>(&mut self, zone_line: line::Zone<'line>) -> Result<(), Error<'line>> {
+    pub fn add_zone_line<'line>(
+        &mut self,
+        zone_line: line::Zone<'line>,
+    ) -> Result<(), Error<'line>> {
         if let line::Saving::Multiple(ruleset_name) = zone_line.info.saving {
             if !self.table.rulesets.contains_key(ruleset_name) {
                 return Err(Error::UnknownRuleset(ruleset_name));
@@ -284,8 +264,8 @@ impl TableBuilder {
         }
 
         let zoneset: &mut _ = match self.table.zonesets.entry(zone_line.name.to_owned()) {
-            Entry::Occupied(_)  => return Err(Error::DuplicateZone),
-            Entry::Vacant(e)    => e.insert(Vec::new()),
+            Entry::Occupied(_) => return Err(Error::DuplicateZone),
+            Entry::Vacant(e) => e.insert(Vec::new()),
         };
 
         zoneset.push(zone_line.info.into());
@@ -297,7 +277,10 @@ impl TableBuilder {
     ///
     /// Returns an error if the builder wasn’t expecting a continuation line
     /// (meaning, the previous line wasn’t a zone line)
-    pub fn add_continuation_line(&mut self, continuation_line: line::ZoneInfo) -> Result<(), Error> {
+    pub fn add_continuation_line(
+        &mut self,
+        continuation_line: line::ZoneInfo,
+    ) -> Result<(), Error> {
         let zoneset: &mut _ = match self.current_zoneset_name {
             Some(ref name) => self.table.zonesets.get_mut(name).unwrap(),
             None => return Err(Error::SurpriseContinuationLine),
@@ -310,9 +293,11 @@ impl TableBuilder {
     /// Adds a new line describing one entry in a ruleset, creating that set
     /// if it didn’t exist already.
     pub fn add_rule_line(&mut self, rule_line: line::Rule) -> Result<(), Error> {
-        let ruleset = self.table.rulesets
-                                .entry(rule_line.name.to_owned())
-                                .or_insert_with(Vec::new);
+        let ruleset = self
+            .table
+            .rulesets
+            .entry(rule_line.name.to_owned())
+            .or_insert_with(Vec::new);
 
         ruleset.push(rule_line.into());
         self.current_zoneset_name = None;
@@ -322,10 +307,13 @@ impl TableBuilder {
     /// Adds a new line linking one zone to another.
     ///
     /// Returns an error if there was already a link with that name.
-    pub fn add_link_line<'line>(&mut self, link_line: line::Link<'line>) -> Result<(), Error<'line>> {
+    pub fn add_link_line<'line>(
+        &mut self,
+        link_line: line::Link<'line>,
+    ) -> Result<(), Error<'line>> {
         match self.table.links.entry(link_line.new.to_owned()) {
-            Entry::Occupied(_)  => Err(Error::DuplicateLink(link_line.new)),
-            Entry::Vacant(e)    => {
+            Entry::Occupied(_) => Err(Error::DuplicateLink(link_line.new)),
+            Entry::Vacant(e) => {
                 let _ = e.insert(link_line.existing.to_owned());
                 self.current_zoneset_name = None;
                 Ok(())
@@ -339,11 +327,9 @@ impl TableBuilder {
     }
 }
 
-
 /// Something that can go wrong while constructing a `Table`.
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub enum Error<'line> {
-
     /// A continuation line was passed in, but the previous line wasn’t a zone
     /// definition line.
     SurpriseContinuationLine,
diff --git a/src/transitions.rs b/src/transitions.rs
index 17e17ad..5769c24 100644
--- a/src/transitions.rs
+++ b/src/transitions.rs
@@ -101,8 +101,7 @@
 //! The logic in this file is based off of `zic.c`, which comes with the
 //! zoneinfo files and is in the public domain.
 
-use table::{Table, Saving, RuleInfo, ZoneInfo};
-
+use table::{RuleInfo, Saving, Table, ZoneInfo};
 
 /// A set of timespans, separated by the instances at which the timespans
 /// change over. There will always be one more timespan than transitions.
@@ -111,7 +110,6 @@ use table::{Table, Saving, RuleInfo, ZoneInfo};
 /// except it uses owned `Vec`s instead of slices.
 #[derive(PartialEq, Debug, Clone)]
 pub struct FixedTimespanSet {
-
     /// The first timespan, which is assumed to have been in effect up until
     /// the initial transition instant (if any). Each set has to have at
     /// least one timespan.
@@ -125,7 +123,6 @@ pub struct FixedTimespanSet {
     pub rest: Vec<(i64, FixedTimespan)>,
 }
 
-
 /// An individual timespan with a fixed offset.
 ///
 /// This mimics the `FixedTimespan` struct in `datetime::cal::zone`, except
@@ -133,7 +130,6 @@ pub struct FixedTimespanSet {
 /// DST fields. Also, the name is an owned `String` here instead of a slice.
 #[derive(PartialEq, Debug, Clone)]
 pub struct FixedTimespan {
-
     /// The number of seconds offset from UTC during this timespan.
     pub utc_offset: i64,
 
@@ -145,25 +141,20 @@ pub struct FixedTimespan {
 }
 
 impl FixedTimespan {
-
     /// The total offset in effect during this timespan.
     pub fn total_offset(&self) -> i64 {
         self.utc_offset + self.dst_offset
     }
 }
 
-
 /// Trait to put the `timespans` method on Tables.
 pub trait TableTransitions {
-
     /// Computes a fixed timespan set for the timezone with the given name.
     /// Returns `None` if the table doesn’t contain a time zone with that name.
     fn timespans(&self, zone_name: &str) -> Option<FixedTimespanSet>;
 }
 
-
 impl TableTransitions for Table {
-
     fn timespans(&self, zone_name: &str) -> Option<FixedTimespanSet> {
         let mut builder = FixedTimespanSetBuilder::default();
 
@@ -174,8 +165,8 @@ impl TableTransitions for Table {
 
         for (i, zone_info) in zoneset.iter().enumerate() {
             let mut dst_offset = 0;
-            let use_until      = i != zoneset.len() - 1;
-            let utc_offset     = zone_info.offset;
+            let use_until = i != zoneset.len() - 1;
+            let utc_offset = zone_info.offset;
 
             let mut insert_start_transition = i > 0;
             let mut start_zone_id = None;
@@ -184,30 +175,59 @@ impl TableTransitions for Table {
 
             match zone_info.saving {
                 Saving::NoSaving => {
-                    builder.add_fixed_saving(zone_info, 0, &mut dst_offset, utc_offset, &mut insert_start_transition, &mut start_zone_id);
-                },
+                    builder.add_fixed_saving(
+                        zone_info,
+                        0,
+                        &mut dst_offset,
+                        utc_offset,
+                        &mut insert_start_transition,
+                        &mut start_zone_id,
+                    );
+                }
 
                 Saving::OneOff(amount) => {
-                    builder.add_fixed_saving(zone_info, amount, &mut dst_offset, utc_offset, &mut insert_start_transition, &mut start_zone_id);
-                },
+                    builder.add_fixed_saving(
+                        zone_info,
+                        amount,
+                        &mut dst_offset,
+                        utc_offset,
+                        &mut insert_start_transition,
+                        &mut start_zone_id,
+                    );
+                }
 
                 Saving::Multiple(ref rules) => {
                     let rules = &self.rulesets[&*rules];
-                    builder.add_multiple_saving(zone_info, &*rules, &mut dst_offset, use_until, utc_offset, &mut insert_start_transition, &mut start_zone_id, &mut start_utc_offset, &mut start_dst_offset);
+                    builder.add_multiple_saving(
+                        zone_info,
+                        &*rules,
+                        &mut dst_offset,
+                        use_until,
+                        utc_offset,
+                        &mut insert_start_transition,
+                        &mut start_zone_id,
+                        &mut start_utc_offset,
+                        &mut start_dst_offset,
+                    );
                 }
             }
 
             if insert_start_transition && start_zone_id.is_some() {
-                let t = (builder.start_time.expect("Start time"), FixedTimespan {
-                    utc_offset: start_utc_offset,
-                    dst_offset: start_dst_offset,
-                    name:       start_zone_id.clone().expect("Start zone ID"),
-                });
+                let t = (
+                    builder.start_time.expect("Start time"),
+                    FixedTimespan {
+                        utc_offset: start_utc_offset,
+                        dst_offset: start_dst_offset,
+                        name: start_zone_id.clone().expect("Start zone ID"),
+                    },
+                );
                 builder.rest.push(t);
             }
 
             if use_until {
-                builder.start_time = Some(zone_info.end_time.expect("End time").to_timestamp() - utc_offset - dst_offset);
+                builder.start_time = Some(
+                    zone_info.end_time.expect("End time").to_timestamp() - utc_offset - dst_offset,
+                );
             }
         }
 
@@ -225,10 +245,15 @@ struct FixedTimespanSetBuilder {
 }
 
 impl FixedTimespanSetBuilder {
-    fn add_fixed_saving(&mut self, timespan: &ZoneInfo, amount: i64,
-            dst_offset: &mut i64, utc_offset: i64, insert_start_transition: &mut bool,
-            start_zone_id: &mut Option<String>)
-    {
+    fn add_fixed_saving(
+        &mut self,
+        timespan: &ZoneInfo,
+        amount: i64,
+        dst_offset: &mut i64,
+        utc_offset: i64,
+        insert_start_transition: &mut bool,
+        start_zone_id: &mut Option<String>,
+    ) {
         *dst_offset = amount;
         *start_zone_id = Some(timespan.format.format(*dst_offset, None));
 
@@ -237,26 +262,33 @@ impl FixedTimespanSetBuilder {
             let timespan = FixedTimespan {
                 utc_offset: timespan.offset,
                 dst_offset: *dst_offset,
-                name:       start_zone_id.clone().unwrap_or_else(String::new),
+                name: start_zone_id.clone().unwrap_or_else(String::new),
             };
 
             self.rest.push((time, timespan));
             *insert_start_transition = false;
-        }
-        else {
+        } else {
             self.first = Some(FixedTimespan {
                 utc_offset: utc_offset,
                 dst_offset: *dst_offset,
-                name:       start_zone_id.clone().unwrap_or_else(String::new),
+                name: start_zone_id.clone().unwrap_or_else(String::new),
             });
         }
     }
 
     #[allow(unused_results)]
-    fn add_multiple_saving(&mut self, timespan: &ZoneInfo, rules: &[RuleInfo],
-            dst_offset: &mut i64, use_until: bool, utc_offset: i64, insert_start_transition: &mut bool,
-            start_zone_id: &mut Option<String>, start_utc_offset: &mut i64, start_dst_offset: &mut i64)
-    {
+    fn add_multiple_saving(
+        &mut self,
+        timespan: &ZoneInfo,
+        rules: &[RuleInfo],
+        dst_offset: &mut i64,
+        use_until: bool,
+        utc_offset: i64,
+        insert_start_transition: &mut bool,
+        start_zone_id: &mut Option<String>,
+        start_utc_offset: &mut i64,
+        start_dst_offset: &mut i64,
+    ) {
         use std::mem::replace;
 
         for year in 1800..2100 {
@@ -264,18 +296,22 @@ impl FixedTimespanSetBuilder {
                 break;
             }
 
-            let mut activated_rules = rules.iter()
-                                           .filter(|r| r.applies_to_year(year))
-                                           .collect::<Vec<_>>();
+            let mut activated_rules = rules
+                .iter()
+                .filter(|r| r.applies_to_year(year))
+                .collect::<Vec<_>>();
 
             loop {
                 if use_until {
-                    self.until_time = Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - *dst_offset);
+                    self.until_time =
+                        Some(timespan.end_time.unwrap().to_timestamp() - utc_offset - *dst_offset);
                 }
 
                 // Find the minimum rule and its start time based on the current
                 // UTC and DST offsets.
-                let earliest = activated_rules.iter().enumerate()
+                let earliest = activated_rules
+                    .iter()
+                    .enumerate()
                     .map(|(i, r)| (i, r.absolute_datetime(year, utc_offset, *dst_offset)))
                     .min_by_key(|&(_, time)| time);
 
@@ -300,24 +336,44 @@ impl FixedTimespanSetBuilder {
                     if earliest_at < self.start_time.unwrap() {
                         replace(start_utc_offset, timespan.offset);
                         replace(start_dst_offset, *dst_offset);
-                        replace(start_zone_id, Some(timespan.format.format(*dst_offset, earliest_rule.letters.as_ref())));
+                        replace(
+                            start_zone_id,
+                            Some(
+                                timespan
+                                    .format
+                                    .format(*dst_offset, earliest_rule.letters.as_ref()),
+                            ),
+                        );
                         continue;
                     }
 
-                    if start_zone_id.is_none() && *start_utc_offset + *start_dst_offset == timespan.offset + *dst_offset {
-                        replace(start_zone_id, Some(timespan.format.format(*dst_offset, earliest_rule.letters.as_ref())));
+                    if start_zone_id.is_none()
+                        && *start_utc_offset + *start_dst_offset == timespan.offset + *dst_offset
+                    {
+                        replace(
+                            start_zone_id,
+                            Some(
+                                timespan
+                                    .format
+                                    .format(*dst_offset, earliest_rule.letters.as_ref()),
+                            ),
+                        );
                     }
                 }
 
-                let t = (earliest_at, FixedTimespan {
-                    utc_offset: timespan.offset,
-                    dst_offset: earliest_rule.time_to_add,
-                    name:       timespan.format.format(earliest_rule.time_to_add, earliest_rule.letters.as_ref()),
-                });
+                let t = (
+                    earliest_at,
+                    FixedTimespan {
+                        utc_offset: timespan.offset,
+                        dst_offset: earliest_rule.time_to_add,
+                        name: timespan
+                            .format
+                            .format(earliest_rule.time_to_add, earliest_rule.letters.as_ref()),
+                    },
+                );
                 self.rest.push(t);
             }
         }
-
     }
 
     fn build(mut self) -> FixedTimespanSet {
@@ -325,19 +381,25 @@ impl FixedTimespanSetBuilder {
 
         let first = match self.first {
             Some(ft) => ft,
-            None     => self.rest.iter().find(|t| t.1.dst_offset == 0).unwrap().1.clone(),
+            None => self
+                .rest
+                .iter()
+                .find(|t| t.1.dst_offset == 0)
+                .unwrap()
+                .1
+                .clone(),
         };
 
         let mut zoneset = FixedTimespanSet {
             first: first,
-            rest:  self.rest,
+            rest: self.rest,
         };
         optimise(&mut zoneset);
         zoneset
     }
 }
 
-#[allow(unused_results)]  // for remove
+#[allow(unused_results)] // for remove
 fn optimise(transitions: &mut FixedTimespanSet) {
     let mut from_i = 0;
     let mut to_i = 0;
@@ -346,7 +408,9 @@ fn optimise(transitions: &mut FixedTimespanSet) {
         if to_i > 1 {
             let from = transitions.rest[from_i].0;
             let to = transitions.rest[to_i - 1].0;
-            if from + transitions.rest[to_i - 1].1.total_offset() <= to + transitions.rest[to_i - 2].1.total_offset() {
+            if from + transitions.rest[to_i - 1].1.total_offset()
+                <= to + transitions.rest[to_i - 2].1.total_offset()
+            {
                 transitions.rest[to_i - 1].1 = transitions.rest[from_i].1.clone();
                 from_i += 1;
                 continue;
@@ -368,11 +432,10 @@ fn optimise(transitions: &mut FixedTimespanSet) {
     }
 }
 
-
 #[cfg(test)]
 mod test {
-    use super::*;
     use super::optimise;
+    use super::*;
 
     // Allow unused results in test code, because the only ‘results’ that
     // we need to ignore are the ones from inserting and removing from
@@ -382,20 +445,108 @@ mod test {
     #[allow(unused_results)]
     fn optimise_macquarie() {
         let mut transitions = FixedTimespanSet {
-            first: FixedTimespan { utc_offset:     0, dst_offset:    0, name:  "zzz".to_owned() },
+            first: FixedTimespan {
+                utc_offset: 0,
+                dst_offset: 0,
+                name: "zzz".to_owned(),
+            },
             rest: vec![
-                (-2_214_259_200, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
-                (-1_680_508_800, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
-                (-1_669_892_400, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),  // gets removed
-                (-1_665_392_400, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
-                (-1_601_719_200, FixedTimespan { utc_offset:     0,  dst_offset:    0,  name:  "zzz".to_owned() }),
-                (  -687_052_800, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
-                (   -94_730_400, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),  // also gets removed
-                (   -71_136_000, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
-                (   -55_411_200, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
-                (   -37_267_200, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
-                (   -25_776_000, FixedTimespan { utc_offset: 36000,  dst_offset:    0,  name: "AEST".to_owned() }),
-                (    -5_817_600, FixedTimespan { utc_offset: 36000,  dst_offset: 3600,  name: "AEDT".to_owned() }),
+                (
+                    -2_214_259_200,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 0,
+                        name: "AEST".to_owned(),
+                    },
+                ),
+                (
+                    -1_680_508_800,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 3600,
+                        name: "AEDT".to_owned(),
+                    },
+                ),
+                (
+                    -1_669_892_400,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 3600,
+                        name: "AEDT".to_owned(),
+                    },
+                ), // gets removed
+                (
+                    -1_665_392_400,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 0,
+                        name: "AEST".to_owned(),
+                    },
+                ),
+                (
+                    -1_601_719_200,
+                    FixedTimespan {
+                        utc_offset: 0,
+                        dst_offset: 0,
+                        name: "zzz".to_owned(),
+                    },
+                ),
+                (
+                    -687_052_800,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 0,
+                        name: "AEST".to_owned(),
+                    },
+                ),
+                (
+                    -94_730_400,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 0,
+                        name: "AEST".to_owned(),
+                    },
+                ), // also gets removed
+                (
+                    -71_136_000,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 3600,
+                        name: "AEDT".to_owned(),
+                    },
+                ),
+                (
+                    -55_411_200,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 0,
+                        name: "AEST".to_owned(),
+                    },
+                ),
+                (
+                    -37_267_200,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 3600,
+                        name: "AEDT".to_owned(),
+                    },
+                ),
+                (
+                    -25_776_000,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 0,
+                        name: "AEST".to_owned(),
+                    },
+                ),
+                (
+                    -5_817_600,
+                    FixedTimespan {
+                        utc_offset: 36000,
+                        dst_offset: 3600,
+                        name: "AEDT".to_owned(),
+                    },
+                ),
             ],
         };
 

From 1ce6c3c6ed305e35c5b700d13e60ec06a70c452a Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Sun, 22 Dec 2019 16:01:43 -0500
Subject: [PATCH 086/113] Support the ">= includes next month" (and <= prev)
 semantics from `tic`

Commit in tz [c86b7fb7b0] changed the tz database to use >= to mean "overflow days
into the next month, if necessary"

This is unfortunately a breaking change, because the month might change and we
need to communicate that back out of `.to_concrete_day()`

[c86b7fb7b0]: https://github.com/eggert/tz/commit/c86b7fb7b0
---
 CHANGELOG.md |   4 +
 Cargo.toml   |   2 +-
 src/line.rs  | 233 ++++++++++++++++++++++++++++++++++++++++++---------
 3 files changed, 198 insertions(+), 41 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e78f907..115a275 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,10 @@
 Changes to parse-zoneinfo
 =========================
 
+# 0.3.0
+
+- Support overflowing month behavior for >= and <= day in month
+
 # 0.2.1
 
 - Build faster by relying on fewer regex features (PR #6 by @bluetech)
diff --git a/Cargo.toml b/Cargo.toml
index 5888e1a..ede0966 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "parse-zoneinfo"
-version = "0.2.1"
+version = "0.3.0"
 authors = ["Djzin <djzin@users.noreply.github.com>"]
 description = "Parse zoneinfo files from the IANA database"
 keywords = ["date", "time", "timezone", "zone", "calendar"]
diff --git a/src/line.rs b/src/line.rs
index a3e885b..73474d5 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -187,6 +187,42 @@ impl Month {
             Month::December => 31,
         }
     }
+
+    /// Get the next calendar month, wrapping such than `December.next() == January`
+    fn next(self) -> Month {
+        match self {
+            Month::January => Month::February,
+            Month::February => Month::March,
+            Month::March => Month::April,
+            Month::April => Month::May,
+            Month::May => Month::June,
+            Month::June => Month::July,
+            Month::July => Month::August,
+            Month::August => Month::September,
+            Month::September => Month::October,
+            Month::October => Month::November,
+            Month::November => Month::December,
+            Month::December => Month::January,
+        }
+    }
+
+    /// Get the previous calendar month, wrapping such that `January.prev() == December`
+    fn prev(self) -> Month {
+        match self {
+            Month::January => Month::December,
+            Month::February => Month::January,
+            Month::March => Month::February,
+            Month::April => Month::March,
+            Month::May => Month::April,
+            Month::June => Month::May,
+            Month::July => Month::June,
+            Month::August => Month::July,
+            Month::September => Month::August,
+            Month::October => Month::September,
+            Month::November => Month::October,
+            Month::December => Month::November,
+        }
+    }
 }
 
 impl FromStr for Month {
@@ -335,21 +371,51 @@ fn leap_years() {
 }
 
 impl DaySpec {
-    pub fn to_concrete_day(&self, year: i64, month: Month) -> i8 {
-        let length = month.length(is_leap(year));
+    pub fn to_concrete_day(&self, year: i64, month: Month) -> (Month, i8) {
+        let leap = is_leap(year);
+        let length = month.length(leap);
+        let prev_length = month.prev().length(leap);
 
         match *self {
-            DaySpec::Ordinal(day) => day,
-            DaySpec::Last(weekday) => (1..length + 1)
+            DaySpec::Ordinal(day) => (month, day),
+            DaySpec::Last(weekday) => (
+                month,
+                (1..length + 1)
+                    .rev()
+                    .find(|&day| Weekday::calculate(year, month, day) == weekday)
+                    .unwrap(),
+            ),
+            DaySpec::LastOnOrBefore(weekday, day) => (-7..day + 1)
                 .rev()
-                .find(|&day| Weekday::calculate(year, month, day) == weekday)
-                .unwrap(),
-            DaySpec::LastOnOrBefore(weekday, day) => (1..day + 1)
-                .rev()
-                .find(|&day| Weekday::calculate(year, month, day) == weekday)
+                .flat_map(|inner_day| {
+                    if inner_day >= 1 && Weekday::calculate(year, month, inner_day) == weekday {
+                        Some((month, inner_day))
+                    } else if inner_day < 1
+                        && Weekday::calculate(year, month.prev(), prev_length + inner_day)
+                            == weekday
+                    {
+                        // inner_day is negative, so this is subtraction
+                        Some((month.prev(), prev_length + inner_day))
+                    } else {
+                        None
+                    }
+                })
+                .next()
                 .unwrap(),
-            DaySpec::FirstOnOrAfter(weekday, day) => (day..length + 1)
-                .find(|&day| Weekday::calculate(year, month, day) == weekday)
+            DaySpec::FirstOnOrAfter(weekday, day) => (day..day + 8)
+                .flat_map(|inner_day| {
+                    if inner_day <= length && Weekday::calculate(year, month, inner_day) == weekday
+                    {
+                        Some((month, inner_day))
+                    } else if inner_day > length
+                        && Weekday::calculate(year, month.next(), inner_day - length) == weekday
+                    {
+                        Some((month.next(), inner_day - length))
+                    } else {
+                        None
+                    }
+                })
+                .next()
                 .unwrap(),
         }
     }
@@ -359,36 +425,116 @@ impl DaySpec {
 #[test]
 fn last_monday() {
     let dayspec = DaySpec::Last(Weekday::Monday);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::January), 25);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::February), 29);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::March), 28);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::April), 25);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::May), 30);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::June), 27);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::July), 25);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::August), 29);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::September), 26);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::October), 31);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::November), 28);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::December), 26);
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::January),
+        (Month::January, 25)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::February),
+        (Month::February, 29)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::March),
+        (Month::March, 28)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::April),
+        (Month::April, 25)
+    );
+    assert_eq!(dayspec.to_concrete_day(2016, Month::May), (Month::May, 30));
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::June),
+        (Month::June, 27)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::July),
+        (Month::July, 25)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::August),
+        (Month::August, 29)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::September),
+        (Month::September, 26)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::October),
+        (Month::October, 31)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::November),
+        (Month::November, 28)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::December),
+        (Month::December, 26)
+    );
 }
 
 #[cfg(test)]
 #[test]
 fn first_monday_on_or_after() {
     let dayspec = DaySpec::FirstOnOrAfter(Weekday::Monday, 20);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::January), 25);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::February), 22);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::March), 21);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::April), 25);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::May), 23);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::June), 20);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::July), 25);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::August), 22);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::September), 26);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::October), 24);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::November), 21);
-    assert_eq!(dayspec.to_concrete_day(2016, Month::December), 26);
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::January),
+        (Month::January, 25)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::February),
+        (Month::February, 22)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::March),
+        (Month::March, 21)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::April),
+        (Month::April, 25)
+    );
+    assert_eq!(dayspec.to_concrete_day(2016, Month::May), (Month::May, 23));
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::June),
+        (Month::June, 20)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::July),
+        (Month::July, 25)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::August),
+        (Month::August, 22)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::September),
+        (Month::September, 26)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::October),
+        (Month::October, 24)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::November),
+        (Month::November, 21)
+    );
+    assert_eq!(
+        dayspec.to_concrete_day(2016, Month::December),
+        (Month::December, 26)
+    );
+}
+
+// A couple of specific timezone transitions that we care about
+#[cfg(test)]
+#[test]
+fn first_sunday_in_toronto() {
+    let dayspec = DaySpec::FirstOnOrAfter(Weekday::Sunday, 25);
+    assert_eq!(dayspec.to_concrete_day(1932, Month::April), (Month::May, 1));
+    // asia/zion
+    let dayspec = DaySpec::LastOnOrBefore(Weekday::Friday, 1);
+    assert_eq!(
+        dayspec.to_concrete_day(2012, Month::April),
+        (Month::March, 30)
+    );
 }
 
 #[derive(PartialEq, Debug, Copy, Clone)]
@@ -506,18 +652,25 @@ impl ChangeTime {
             ChangeTime::UntilYear(Year::Number(y)) => time_to_timestamp(y, 1, 1, 0, 0, 0),
             ChangeTime::UntilMonth(Year::Number(y), m) => time_to_timestamp(y, m as i8, 1, 0, 0, 0),
             ChangeTime::UntilDay(Year::Number(y), m, d) => {
-                time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), 0, 0, 0)
+                let (m, wd) = d.to_concrete_day(y, m);
+                time_to_timestamp(y, m as i8, wd, 0, 0, 0)
             }
             ChangeTime::UntilTime(Year::Number(y), m, d, time) => match time.0 {
-                TimeSpec::Zero => time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), 0, 0, 0),
+                TimeSpec::Zero => {
+                    let (m, wd) = d.to_concrete_day(y, m);
+                    time_to_timestamp(y, m as i8, wd, 0, 0, 0)
+                }
                 TimeSpec::Hours(h) => {
-                    time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, 0, 0)
+                    let (m, wd) = d.to_concrete_day(y, m);
+                    time_to_timestamp(y, m as i8, wd, h, 0, 0)
                 }
                 TimeSpec::HoursMinutes(h, min) => {
-                    time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, min, 0)
+                    let (m, wd) = d.to_concrete_day(y, m);
+                    time_to_timestamp(y, m as i8, wd, h, min, 0)
                 }
                 TimeSpec::HoursMinutesSeconds(h, min, s) => {
-                    time_to_timestamp(y, m as i8, d.to_concrete_day(y, m), h, min, s)
+                    let (m, wd) = d.to_concrete_day(y, m);
+                    time_to_timestamp(y, m as i8, wd, h, min, s)
                 }
             },
             _ => unreachable!(),

From ffbc3b74607116350f44a291476b02c41ef24189 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Sun, 22 Dec 2019 17:01:36 -0500
Subject: [PATCH 087/113] Run github actions on pull request

---
 .github/workflows/rust-test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/rust-test.yml b/.github/workflows/rust-test.yml
index ddbdf92..38aa462 100644
--- a/.github/workflows/rust-test.yml
+++ b/.github/workflows/rust-test.yml
@@ -1,6 +1,6 @@
 name: Rust
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   build:

From 46d9d67a47cae2006231d0434d51daeb0cd08666 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Mon, 23 Dec 2019 12:01:34 -0500
Subject: [PATCH 088/113] Change >=/<= behavior to panic on year overflow

I'm not sure what the semantics are of that in tic, but none exist now and
hopefully no tz rules are set up by governments such that it's possible for
them to ovrflow years.
---
 src/line.rs | 40 ++++++++++++++++++++++++----------------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index 73474d5..9a2cd3d 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -188,9 +188,9 @@ impl Month {
         }
     }
 
-    /// Get the next calendar month, wrapping such than `December.next() == January`
-    fn next(self) -> Month {
-        match self {
+    /// Get the next calendar month, with an error going from Dec->Jan
+    fn next_in_year(self) -> Result<Month, &'static str> {
+        Ok(match self {
             Month::January => Month::February,
             Month::February => Month::March,
             Month::March => Month::April,
@@ -202,14 +202,14 @@ impl Month {
             Month::September => Month::October,
             Month::October => Month::November,
             Month::November => Month::December,
-            Month::December => Month::January,
-        }
+            Month::December => Err("Cannot wrap year from dec->jan")?,
+        })
     }
 
-    /// Get the previous calendar month, wrapping such that `January.prev() == December`
-    fn prev(self) -> Month {
-        match self {
-            Month::January => Month::December,
+    /// Get the previous calendar month, with an error going from Jan->Dec
+    fn prev_in_year(self) -> Result<Month, &'static str> {
+        Ok(match self {
+            Month::January => Err("Cannot wrap years from jan->dec")?,
             Month::February => Month::January,
             Month::March => Month::February,
             Month::April => Month::March,
@@ -221,7 +221,7 @@ impl Month {
             Month::October => Month::September,
             Month::November => Month::October,
             Month::December => Month::November,
-        }
+        })
     }
 }
 
@@ -374,7 +374,8 @@ impl DaySpec {
     pub fn to_concrete_day(&self, year: i64, month: Month) -> (Month, i8) {
         let leap = is_leap(year);
         let length = month.length(leap);
-        let prev_length = month.prev().length(leap);
+        // we will never hit the 0 because we unwrap prev_in_year below
+        let prev_length = month.prev_in_year().map(|m| m.length(leap)).unwrap_or(0);
 
         match *self {
             DaySpec::Ordinal(day) => (month, day),
@@ -391,11 +392,14 @@ impl DaySpec {
                     if inner_day >= 1 && Weekday::calculate(year, month, inner_day) == weekday {
                         Some((month, inner_day))
                     } else if inner_day < 1
-                        && Weekday::calculate(year, month.prev(), prev_length + inner_day)
-                            == weekday
+                        && Weekday::calculate(
+                            year,
+                            month.prev_in_year().unwrap(),
+                            prev_length + inner_day,
+                        ) == weekday
                     {
                         // inner_day is negative, so this is subtraction
-                        Some((month.prev(), prev_length + inner_day))
+                        Some((month.prev_in_year().unwrap(), prev_length + inner_day))
                     } else {
                         None
                     }
@@ -408,9 +412,13 @@ impl DaySpec {
                     {
                         Some((month, inner_day))
                     } else if inner_day > length
-                        && Weekday::calculate(year, month.next(), inner_day - length) == weekday
+                        && Weekday::calculate(
+                            year,
+                            month.next_in_year().unwrap(),
+                            inner_day - length,
+                        ) == weekday
                     {
-                        Some((month.next(), inner_day - length))
+                        Some((month.next_in_year().unwrap(), inner_day - length))
                     } else {
                         None
                     }

From e8aecaebb16f480abda97ad23e11b5d0efd94b12 Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:10:46 +0100
Subject: [PATCH 089/113] Specify minimum Rust version

---
 .travis.yml | 35 ++++++++++-------------------------
 README.md   | 15 ++++++++++++++-
 2 files changed, 24 insertions(+), 26 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 2b2d239..e22719e 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,30 +1,15 @@
 language: rust
-sudo: required
 rust:
-  - nightly
-  - beta
+  - 1.31.0
   - stable
+  - beta
+  - nightly
 
-addons:
-  apt:
-    packages:
-      - libcurl4-openssl-dev
-      - libelf-dev
-      - libdw-dev
-
-before_script:
-  - |
-      pip install 'travis-cargo<0.2' --user &&
-      export PATH=$HOME/.local/bin:$PATH
-
-script:
-  - |
-      travis-cargo build &&
-      travis-cargo test
-
-after_success:
-  - travis-cargo coveralls --no-sudo
+os:
+  - linux
+  - osx
+  - windows
 
-env:
-  global:
-    - TRAVIS_CARGO_NIGHTLY_FEATURE=""
+matrix:
+  allow_failures:
+    - rust: nightly
diff --git a/README.md b/README.md
index ddbf1c3..de51a30 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,20 @@ The database itself is maintained by IANA. For more information, see [IANA’s p
 ### [View the Rustdoc](https://docs.rs/zoneinfo_parse)
 
 
-## Format
+# Installation
+
+This crate works with [Cargo](https://crates.io). Add the following to your `Cargo.toml` dependencies section:
+
+```toml
+[dependencies]
+datetime = "0.4"
+zoneinfo_parse = "0.1"
+```
+
+The earliest version of Rust that this crate is tested against is [Rust v1.31.0](https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html).
+
+
+# Usage
 
 The zoneinfo files contains `Zone`, `Rule`, and `Link` information. Each type of line forms a variant in the `line::Line` enum.
 

From 0faccfefda2f04756d47c3c86c20e22fe6ecc413 Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:10:50 +0100
Subject: [PATCH 090/113] Add licence

---
 LICENCE | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 LICENCE

diff --git a/LICENCE b/LICENCE
new file mode 100644
index 0000000..3c0c3fa
--- /dev/null
+++ b/LICENCE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Benjamin Sago
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

From 50a4310c11c680ba71e6ea94a6f5e27bbf7c77d6 Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:14:48 +0100
Subject: [PATCH 091/113] Metadata changes

---
 Cargo.toml | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 6181182..a5fc240 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,12 +2,13 @@
 name = "zoneinfo_parse"
 description = "Library for parsing zoneinfo time zone files"
 
-version = "0.1.4"
+authors = ["Ben S <ogham@bsago.me>"]
 documentation = "https://docs.rs/zoneinfo_parse"
-homepage = "https://github.com/rust-datetime/zoneinfo-compiled"
+exclude = ["/README.md", "/LICENCE", "/.rustfmt.toml", "/.travis.yml"]
 license = "MIT"
 readme = "README.md"
-authors = ["Ben S <ogham@bsago.me>"]
+repository = "https://github.com/rust-datetime/zoneinfo-compiled"
+version = "0.1.4"
 
 [dependencies]
 datetime = "0.4.4"

From 59da8022cfc66c223cf0e54997286a6cf4ab036f Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:21:16 +0100
Subject: [PATCH 092/113] Upgrade Rust and Regex

---
 Cargo.toml  |  6 ++---
 src/line.rs | 63 ++++++++++++++++++++++++++---------------------------
 2 files changed, 34 insertions(+), 35 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index a5fc240..0671270 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,6 +11,6 @@ repository = "https://github.com/rust-datetime/zoneinfo-compiled"
 version = "0.1.4"
 
 [dependencies]
-datetime = "0.4.4"
-lazy_static = "0.2.1"
-regex = "0.1.77"
+datetime = "0.4"
+lazy_static = "1.4"
+regex = "1.3"
diff --git a/src/line.rs b/src/line.rs
index 4a89c15..ffb509d 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -77,7 +77,6 @@
 //! })));
 //! ```
 
-use std::ascii::AsciiExt;
 use std::error::Error as ErrorTrait;
 use std::fmt;
 use std::str::FromStr;
@@ -217,12 +216,12 @@ impl<'line> Rule<'line> {
     /// Attempts to parse the given string into a value of this type.
     pub fn from_str(input: &str) -> Result<Rule, Error> {
         if let Some(caps) = RULE_LINE.captures(input) {
-            let name      = caps.name("name").unwrap();
-            let from_year = try!(caps.name("from").unwrap().parse());
+            let name      = caps.name("name").unwrap().as_str();
+            let from_year = try!(caps.name("from").unwrap().as_str().parse());
 
             // The end year can be ‘only’ to indicate that this rule only
             // takes place on that year.
-            let to_year = match caps.name("to").unwrap() {
+            let to_year = match caps.name("to").unwrap().as_str() {
                 "only"  => None,
                 to      => Some(try!(to.parse())),
             };
@@ -231,16 +230,16 @@ impl<'line> Rule<'line> {
             // should be “-”, so throw an error if it isn’t. (It only exists
             // for compatibility with old versions that used to contain year
             // types.) Sometimes “‐”, a Unicode hyphen, is used as well.
-            let t = caps.name("type").unwrap();
+            let t = caps.name("type").unwrap().as_str();
             if t != "-" && t != "\u{2010}"  {
                 return Err(Error::Fail);
             }
 
-            let month        = try!(caps.name("in").unwrap().parse());
-            let day          = try!(caps.name("on").unwrap().parse());
-            let time         = try!(caps.name("at").unwrap().parse());
-            let time_to_add  = try!(caps.name("save").unwrap().parse());
-            let letters      = match caps.name("letters").unwrap() {
+            let month        = try!(caps.name("in").unwrap().as_str().parse());
+            let day          = try!(caps.name("on").unwrap().as_str().parse());
+            let time         = try!(caps.name("at").unwrap().as_str().parse());
+            let time_to_add  = try!(caps.name("save").unwrap().as_str().parse());
+            let letters      = match caps.name("letters").unwrap().as_str() {
                 "-"  => None,
                 l    => Some(l),
             };
@@ -297,7 +296,7 @@ impl<'line> Zone<'line> {
     /// Attempts to parse the given string into a value of this type.
     pub fn from_str(input: &str) -> Result<Zone, Error> {
         if let Some(caps) = ZONE_LINE.captures(input) {
-            let name = caps.name("name").unwrap();
+            let name = caps.name("name").unwrap().as_str();
             let info = try!(ZoneInfo::from_captures(caps));
 
             Ok(Zone {
@@ -334,18 +333,18 @@ pub struct ZoneInfo<'line> {
 
 impl<'line> ZoneInfo<'line> {
     fn from_captures(caps: Captures<'line>) -> Result<ZoneInfo<'line>, Error> {
-        let utc_offset    = try!(caps.name("gmtoff").unwrap().parse());
-        let saving        = try!(Saving::from_str(caps.name("rulessave").unwrap()));
-        let format        = caps.name("format").unwrap();
+        let utc_offset    = try!(caps.name("gmtoff").unwrap().as_str().parse());
+        let saving        = try!(Saving::from_str(caps.name("rulessave").unwrap().as_str()));
+        let format        = caps.name("format").unwrap().as_str();
 
         // The year, month, day, and time fields are all optional, meaning
         // that it should be impossible to, say, have a defined month but not
         // a defined year.
         let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
-            (Some(y), Some(m), Some(d), Some(t)) => Some(ChangeTime::UntilTime  (try!(y.parse()), try!(m.parse()), try!(d.parse()), try!(t.parse()))),
-            (Some(y), Some(m), Some(d), _      ) => Some(ChangeTime::UntilDay   (try!(y.parse()), try!(m.parse()), try!(d.parse()))),
-            (Some(y), Some(m), _      , _      ) => Some(ChangeTime::UntilMonth (try!(y.parse()), try!(m.parse()))),
-            (Some(y), _      , _      , _      ) => Some(ChangeTime::UntilYear  (try!(y.parse()))),
+            (Some(y), Some(m), Some(d), Some(t)) => Some(ChangeTime::UntilTime  (try!(y.as_str().parse()), try!(m.as_str().parse()), try!(d.as_str().parse()), try!(t.as_str().parse()))),
+            (Some(y), Some(m), Some(d), _      ) => Some(ChangeTime::UntilDay   (try!(y.as_str().parse()), try!(m.as_str().parse()), try!(d.as_str().parse()))),
+            (Some(y), Some(m), _      , _      ) => Some(ChangeTime::UntilMonth (try!(y.as_str().parse()), try!(m.as_str().parse()))),
+            (Some(y), _      , _      , _      ) => Some(ChangeTime::UntilYear  (try!(y.as_str().parse()))),
             (None   , None   , None   , None   ) => None,
             _                                    => unreachable!("Out-of-order capturing groups!"),
         };
@@ -466,8 +465,8 @@ impl<'line> Link<'line> {
     /// Attempts to parse the given string into a value of this type.
     pub fn from_str(input: &str) -> Result<Link, Error> {
         if let Some(caps) = LINK_LINE.captures(input) {
-            let target  = caps.name("target").unwrap();
-            let name    = caps.name("name").unwrap();
+            let target  = caps.name("target").unwrap().as_str();
+            let name    = caps.name("name").unwrap().as_str();
             Ok(Link { existing: target, new: name })
         }
         else {
@@ -643,10 +642,10 @@ impl FromStr for DaySpec {
 
         // Check if it’s a relative expression with the regex.
         else if let Some(caps) = DAY_FIELD.captures(input) {
-            let weekday = caps.name("weekday").unwrap().parse().unwrap();
-            let day     = caps.name("day").unwrap().parse().unwrap();
+            let weekday = caps.name("weekday").unwrap().as_str().parse().unwrap();
+            let day     = caps.name("day").unwrap().as_str().parse().unwrap();
 
-            match caps.name("sign").unwrap() {
+            match caps.name("sign").unwrap().as_str() {
                 "<=" => Ok(DaySpec::LastOnOrBefore(weekday, day)),
                 ">=" => Ok(DaySpec::FirstOnOrAfter(weekday, day)),
                  _   => unreachable!("The regex only matches one of those two!"),
@@ -720,20 +719,20 @@ impl FromStr for TimeSpecAndType {
             Ok(TimeSpecAndType(TimeSpec::Hours(input.parse().unwrap()), TimeType::Wall))
         }
         else if let Some(caps) = HM_FIELD.captures(input) {
-            let sign   : i8 = if caps.name("sign").unwrap() == "-" { -1 } else { 1 };
-            let hour   : i8 = caps.name("hour").unwrap().parse().unwrap();
-            let minute : i8 = caps.name("minute").unwrap().parse().unwrap();
-            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
+            let sign   : i8 = if caps.name("sign").unwrap().as_str() == "-" { -1 } else { 1 };
+            let hour   : i8 = caps.name("hour").unwrap().as_str().parse().unwrap();
+            let minute : i8 = caps.name("minute").unwrap().as_str().parse().unwrap();
+            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c.as_str()[0..1]))
                                           .unwrap_or(TimeType::Wall);
 
             Ok(TimeSpecAndType(TimeSpec::HoursMinutes(hour * sign, minute * sign), flag))
         }
         else if let Some(caps) = HMS_FIELD.captures(input) {
-            let sign   : i8 = if caps.name("sign").unwrap() == "-" { -1 } else { 1 };
-            let hour   : i8 = caps.name("hour").unwrap().parse().unwrap();
-            let minute : i8 = caps.name("minute").unwrap().parse().unwrap();
-            let second : i8 = caps.name("second").unwrap().parse().unwrap();
-            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c[0..1]))
+            let sign   : i8 = if caps.name("sign").unwrap().as_str() == "-" { -1 } else { 1 };
+            let hour   : i8 = caps.name("hour").unwrap().as_str().parse().unwrap();
+            let minute : i8 = caps.name("minute").unwrap().as_str().parse().unwrap();
+            let second : i8 = caps.name("second").unwrap().as_str().parse().unwrap();
+            let flag        = caps.name("flag").and_then(|c| parse_time_type(&c.as_str()[0..1]))
                                           .unwrap_or(TimeType::Wall);
 
             Ok(TimeSpecAndType(TimeSpec::HoursMinutesSeconds(hour * sign, minute * sign, second * sign), flag))

From aecc9c15da09f28ed3ab3b61a8ef5e3062b27e04 Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:21:55 +0100
Subject: [PATCH 093/113] Two fewer mutable variables

---
 src/table.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/table.rs b/src/table.rs
index 866b69a..7848a25 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -324,7 +324,7 @@ impl TableBuilder {
             }
         }
 
-        let mut zoneset = match self.table.zonesets.entry(zone_line.name.to_owned()) {
+        let zoneset = match self.table.zonesets.entry(zone_line.name.to_owned()) {
             Entry::Occupied(_)  => return Err(Error::DuplicateZone),
             Entry::Vacant(e)    => e.insert(Vec::new()),
         };
@@ -339,7 +339,7 @@ impl TableBuilder {
     /// Returns an error if the builder wasn’t expecting a continuation line
     /// (meaning, the previous line wasn’t a zone line)
     pub fn add_continuation_line(&mut self, continuation_line: line::ZoneInfo) -> Result<(), Error> {
-        let mut zoneset = match self.current_zoneset_name {
+        let zoneset = match self.current_zoneset_name {
             Some(ref name) => self.table.zonesets.get_mut(name).unwrap(),
             None => return Err(Error::SurpriseContinuationLine),
         };

From cd78b649cff939e51eb5286230c361b6e7b1c624 Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:23:18 +0100
Subject: [PATCH 094/113] New set of crate attributes

---
 src/lib.rs  | 15 +++++----------
 src/line.rs |  6 +++---
 2 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 3384c50..2e9803f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -27,17 +27,12 @@
 //! - **Calculating transitions** from this table is done by the `transitions`
 //!   module.
 
-#![crate_name = "zoneinfo_parse"]
-#![crate_type = "rlib"]
-#![crate_type = "dylib"]
-
 #![warn(missing_copy_implementations)]
-#![warn(missing_debug_implementations)]
-#![warn(missing_docs)]
-
-#![warn(trivial_casts, trivial_numeric_casts)]
-#![warn(unused_qualifications)]
-#![warn(unused_results)]
+//#![warn(missing_docs)]
+#![warn(nonstandard_style)]
+#![warn(trivial_numeric_casts)]
+#![warn(unreachable_pub)]
+#![warn(unused)]
 
 extern crate datetime;
 extern crate regex;
diff --git a/src/line.rs b/src/line.rs
index ffb509d..b4c3ab9 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -839,9 +839,9 @@ impl<'line> Line<'line> {
 
 #[cfg(test)]
 mod test {
-    pub use std::str::FromStr;
-    pub use super::*;
-    pub use datetime::{Weekday, Month};
+    pub(crate) use std::str::FromStr;
+    pub(crate) use super::*;
+    pub(crate) use datetime::{Weekday, Month};
 
     macro_rules! test {
         ($name:ident: $input:expr => $result:expr) => {

From 91e1b037c469ddf5f642d0f075e53606b84a48ee Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:24:55 +0100
Subject: [PATCH 095/113] Inline some constructor fields

---
 src/line.rs      | 16 ++--------------
 src/structure.rs |  5 +----
 2 files changed, 3 insertions(+), 18 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index b4c3ab9..56f5b1c 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -244,16 +244,7 @@ impl<'line> Rule<'line> {
                 l    => Some(l),
             };
 
-            Ok(Rule {
-                name:         name,
-                from_year:    from_year,
-                to_year:      to_year,
-                month:        month,
-                day:          day,
-                time:         time,
-                time_to_add:  time_to_add,
-                letters:      letters,
-            })
+            Ok(Rule { name, from_year, to_year, month, day, time, time_to_add, letters })
         }
         else {
             Err(Error::Fail)
@@ -299,10 +290,7 @@ impl<'line> Zone<'line> {
             let name = caps.name("name").unwrap().as_str();
             let info = try!(ZoneInfo::from_captures(caps));
 
-            Ok(Zone {
-                name: name,
-                info: info,
-            })
+            Ok(Zone { name, info })
         }
         else {
             Err(Error::Fail)
diff --git a/src/structure.rs b/src/structure.rs
index 73ce7a6..a99dd6c 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -97,10 +97,7 @@ impl<'table> IntoIterator for TableStructure<'table> {
         let mut keys: Vec<_> = self.mappings.keys().cloned().collect();
         keys.sort_by(|a, b| b.cmp(a));
 
-        Iter {
-            structure: self,
-            keys: keys,
-        }
+        Iter { structure: self, keys }
     }
 }
 

From f380eea7738f798ca35cfae1cf76d9f5f3aea7da Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:26:01 +0100
Subject: [PATCH 096/113] =?UTF-8?q?Remove=20loop=20that=20didn=E2=80=99t?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/structure.rs | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/structure.rs b/src/structure.rs
index a99dd6c..994f18b 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -112,20 +112,18 @@ impl<'table> Iterator for Iter<'table> {
     type Item = TableStructureEntry<'table>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            let key = match self.keys.pop() {
-                Some(k) => k,
-                None    => return None,
-            };
-
-            // Move the strings out into an (automatically-sorted) vector.
-            let values = self.structure.mappings[key].iter().cloned().collect();
-
-            return Some(TableStructureEntry {
-                name: key,
-                children: values,
-            });
-        }
+        let key = match self.keys.pop() {
+            Some(k) => k,
+            None    => return None,
+        };
+
+        // Move the strings out into an (automatically-sorted) vector.
+        let values = self.structure.mappings[key].iter().cloned().collect();
+
+        Some(TableStructureEntry {
+            name: key,
+            children: values,
+        })
     }
 }
 

From 616a274e6cc10d137c943ab836248f556920e57a Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:32:51 +0100
Subject: [PATCH 097/113] =?UTF-8?q?try!=20=E2=86=92=20=3F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I’m really getting with the times.
---
 data-crate-builder/src/data_crate.rs | 81 ++++++++++++++--------------
 data-crate-builder/src/errors.rs     |  5 +-
 data-crate-builder/src/main.rs       |  6 +--
 src/line.rs                          | 32 +++++------
 src/structure.rs                     |  5 +-
 5 files changed, 64 insertions(+), 65 deletions(-)

diff --git a/data-crate-builder/src/data_crate.rs b/data-crate-builder/src/data_crate.rs
index a3ff92f..ed4f6cb 100644
--- a/data-crate-builder/src/data_crate.rs
+++ b/data-crate-builder/src/data_crate.rs
@@ -46,7 +46,7 @@ impl DataCrate {
         let mut errors = Vec::new();
 
         for arg in input_file_paths {
-            let f = try!(File::open(arg));
+            let f = File::open(arg)?;
             let reader = BufReader::new(f);
 
             for (line_number, line) in reader.lines().enumerate() {
@@ -109,8 +109,8 @@ impl DataCrate {
     /// data goes in (and the `mod.rs` files for those directories), and then
     /// creating the files inside those directories.
     pub fn run(&self) -> IOResult<()> {
-        try!(self.create_structure_directories());
-        try!(self.write_zonesets());
+        self.create_structure_directories()?;
+        self.write_zonesets()?;
         Ok(())
     }
 
@@ -121,35 +121,35 @@ impl DataCrate {
         open_opts.write(true).create(true).truncate(true);
 
         let base_mod_path = self.base_path.join("mod.rs");
-        let mut base_w = try!(open_opts.open(base_mod_path));
+        let mut base_w = open_opts.open(base_mod_path)?;
 
-        try!(writeln!(base_w, "{}", WARNING_HEADER));
-        try!(writeln!(base_w, "{}", MOD_HEADER));
+        writeln!(base_w, "{}", WARNING_HEADER)?;
+        writeln!(base_w, "{}", MOD_HEADER)?;
 
         for entry in self.table.structure() {
             if !entry.name.contains('/') {
-                try!(writeln!(base_w, "pub mod {};", entry.name));
+                writeln!(base_w, "pub mod {};", entry.name)?;
             }
 
             let components: PathBuf = entry.name.split('/').collect();
             let dir_path = self.base_path.join(components);
             if !dir_path.is_dir() {
                 println!("Creating directory {:?}", &dir_path);
-                try!(create_dir(&dir_path));
+                create_dir(&dir_path)?;
             }
 
             let mod_path = dir_path.join("mod.rs");
-            let mut w = try!(open_opts.open(mod_path));
+            let mut w = open_opts.open(mod_path)?;
             for child in &entry.children {
                 match *child {
                     Child::TimeZone(ref name) => {
                         let sanichild = sanitise_name(name);
-                        try!(writeln!(w, "mod {};", sanichild));
-                        try!(writeln!(w, "pub use self::{}::ZONE as {};\n", sanichild, sanichild));
+                        writeln!(w, "mod {};", sanichild)?;
+                        writeln!(w, "pub use self::{}::ZONE as {};\n", sanichild, sanichild)?;
                     },
                     Child::Submodule(ref name) => {
                         let sanichild = sanitise_name(name);
-                        try!(writeln!(w, "pub mod {};\n", sanichild));
+                        writeln!(w, "pub mod {};\n", sanichild)?;
                     },
                 }
             }
@@ -158,25 +158,25 @@ impl DataCrate {
         let mut keys: Vec<_> = self.table.zonesets.keys().chain(self.table.links.keys()).collect();
         keys.sort();
 
-        try!(writeln!(base_w, "\n\n"));
+        writeln!(base_w, "\n\n")?;
         for name in keys.iter().filter(|f| !f.contains('/')) {
             let sanichild = sanitise_name(name);
-            try!(writeln!(base_w, "mod {};", sanichild));
-            try!(writeln!(base_w, "pub use self::{}::ZONE as {};\n", sanichild, sanichild));
+            writeln!(base_w, "mod {};", sanichild)?;
+            writeln!(base_w, "pub use self::{}::ZONE as {};\n", sanichild, sanichild)?;
         }
 
-        try!(writeln!(base_w, "\n\n"));
-        try!(write!(base_w, "static ZONES: phf::Map<&'static str, &'static StaticTimeZone<'static>> = "));
+        writeln!(base_w, "\n\n")?;
+        write!(base_w, "static ZONES: phf::Map<&'static str, &'static StaticTimeZone<'static>> = ")?;
 
         let mut phf_map = PHFMap::new();
         for name in &keys {
             phf_map.entry(&***name, &format!("&{}", sanitise_name(name).replace("/", "::")));
         }
-        try!(phf_map.build(&mut base_w));
+        phf_map.build(&mut base_w)?;
 
-        try!(writeln!(base_w, ";\n\npub fn lookup(input: &str) -> Option<&'static StaticTimeZone<'static>> {{"));
-        try!(writeln!(base_w, "    ZONES.get(input).cloned()"));
-        try!(writeln!(base_w, "}}"));
+        writeln!(base_w, ";\n\npub fn lookup(input: &str) -> Option<&'static StaticTimeZone<'static>> {{")?;
+        writeln!(base_w, "    ZONES.get(input).cloned()")?;
+        writeln!(base_w, "}}")?;
 
         Ok(())
     }
@@ -186,37 +186,38 @@ impl DataCrate {
         for name in self.table.zonesets.keys().chain(self.table.links.keys()) {
             let components: PathBuf = name.split('/').map(sanitise_name).collect();
             let zoneset_path = self.base_path.join(components).with_extension("rs");
-            let mut w = try!(OpenOptions::new().write(true).create(true).truncate(true).open(zoneset_path));
-            try!(writeln!(w, "{}", WARNING_HEADER));
-            try!(writeln!(w, "{}", ZONEINFO_HEADER));
+            let mut w = OpenOptions::new().write(true).create(true).truncate(true).open(zoneset_path);
+            writeln!(w, "{}", WARNING_HEADER)?;
+            writeln!(w, "{}", ZONEINFO_HEADER)?;
 
-            try!(writeln!(w, "pub static ZONE: StaticTimeZone<'static> = StaticTimeZone {{"));
-            try!(writeln!(w, "    name: {:?},", name));
-            try!(writeln!(w, "    fixed_timespans: FixedTimespanSet {{"));
+            writeln!(w, "pub static ZONE: StaticTimeZone<'static> = StaticTimeZone {{")?;
+            writeln!(w, "    name: {:?},", name)?;
+            writeln!(w, "    fixed_timespans: FixedTimespanSet {{")?;
 
             let set = self.table.timespans(&*name).unwrap();
 
-            try!(writeln!(w, "        first: FixedTimespan {{"));
-            try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", set.first.total_offset(), set.first.utc_offset, set.first.dst_offset));
-            try!(writeln!(w, "            is_dst: {:?},", set.first.dst_offset != 0));
-            try!(writeln!(w, "            name:   Cow::Borrowed({:?}),", set.first.name));
-            try!(writeln!(w, "        }},"));
+            writeln!(w, "        first: FixedTimespan {{")?;
+            writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", set.first.total_offset(), set.first.utc_offset, set.first.dst_offset)?;
+            writeln!(w, "            is_dst: {:?},", set.first.dst_offset != 0)?;
+            writeln!(w, "            name:   Cow::Borrowed({:?}),", set.first.name)?;
+            writeln!(w, "        }},")?;
 
-            try!(writeln!(w, "        rest: &["));
+            writeln!(w, "        rest: &[")?;
 
             for t in &set.rest {
-                try!(writeln!(w, "        ({:?}, FixedTimespan {{  // {} UTC", t.0, LocalDateTime::at(t.0).iso()));
+                writeln!(w, "        ({:?}, FixedTimespan {{  // {} UTC", t.0, LocalDateTime::at(t.0).iso())?;
 
                 // Write the total offset (the only value that gets used)
                 // and both the offsets that get added together, as a
                 // comment in the data crate.
-                try!(writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", t.1.total_offset(), t.1.utc_offset, t.1.dst_offset));
-                try!(writeln!(w, "            is_dst: {:?},", t.1.dst_offset != 0));
-                try!(writeln!(w, "            name:   Cow::Borrowed({:?}),", t.1.name));
-                try!(writeln!(w, "        }}),"));
+                writeln!(w, "            offset: {:?},  // UTC offset {:?}, DST offset {:?}", t.1.total_offset(), t.1.utc_offset, t.1.dst_offset)?;
+                writeln!(w, "            is_dst: {:?},", t.1.dst_offset != 0)?;
+                writeln!(w, "            name:   Cow::Borrowed({:?}),", t.1.name)?;
+                writeln!(w, "        }}),")?;
             }
-            try!(writeln!(w, "    ]}},"));
-            try!(writeln!(w, "}};\n\n"));
+            writeln!(w, "    ]}},")?;
+
+            writeln!(w, "}};\n\n")?;
         }
 
         Ok(())
diff --git a/data-crate-builder/src/errors.rs b/data-crate-builder/src/errors.rs
index 1d6bc18..62c33fb 100644
--- a/data-crate-builder/src/errors.rs
+++ b/data-crate-builder/src/errors.rs
@@ -56,8 +56,9 @@ pub struct Errors(Vec<ParseError>);
 impl fmt::Display for Errors {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         for err in &self.0 {
-            try!(write!(f, "{}:{}: {}\n", err.filename, err.line, err.error));
+            write!(f, "{}:{}: {}\n", err.filename, err.line, err.error)?;
         }
+
         Ok(())
     }
-}
\ No newline at end of file
+}
diff --git a/data-crate-builder/src/main.rs b/data-crate-builder/src/main.rs
index a5b9660..2ecd33f 100644
--- a/data-crate-builder/src/main.rs
+++ b/data-crate-builder/src/main.rs
@@ -31,9 +31,9 @@ fn build_data_crate() -> Result<(), Error> {
     let mut opts = getopts::Options::new();
     opts.reqopt("o", "output", "directory to write the crate into", "DIR");
 
-    let matches = try!(opts.parse(args_os().skip(1)));
-    let data_crate = try!(DataCrate::new(matches.opt_str("output").unwrap(), &matches.free));
-    try!(data_crate.run());
+    let matches = opts.parse(args_os().skip(1))?;
+    let data_crate = DataCrate::new(matches.opt_str("output").unwrap(), &matches.free)?;
+    data_crate.run()?;
 
     println!("All done.");
     Ok(())
diff --git a/src/line.rs b/src/line.rs
index 56f5b1c..ab88261 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -217,13 +217,13 @@ impl<'line> Rule<'line> {
     pub fn from_str(input: &str) -> Result<Rule, Error> {
         if let Some(caps) = RULE_LINE.captures(input) {
             let name      = caps.name("name").unwrap().as_str();
-            let from_year = try!(caps.name("from").unwrap().as_str().parse());
+            let from_year = caps.name("from").unwrap().as_str().parse()?;
 
             // The end year can be ‘only’ to indicate that this rule only
             // takes place on that year.
             let to_year = match caps.name("to").unwrap().as_str() {
                 "only"  => None,
-                to      => Some(try!(to.parse())),
+                to      => Some(to.parse()?),
             };
 
             // According to the spec, the only value inside the ‘type’ column
@@ -235,10 +235,10 @@ impl<'line> Rule<'line> {
                 return Err(Error::Fail);
             }
 
-            let month        = try!(caps.name("in").unwrap().as_str().parse());
-            let day          = try!(caps.name("on").unwrap().as_str().parse());
-            let time         = try!(caps.name("at").unwrap().as_str().parse());
-            let time_to_add  = try!(caps.name("save").unwrap().as_str().parse());
+            let month        = caps.name("in").unwrap().as_str().parse()?;
+            let day          = caps.name("on").unwrap().as_str().parse()?;
+            let time         = caps.name("at").unwrap().as_str().parse()?;
+            let time_to_add  = caps.name("save").unwrap().as_str().parse()?;
             let letters      = match caps.name("letters").unwrap().as_str() {
                 "-"  => None,
                 l    => Some(l),
@@ -288,7 +288,7 @@ impl<'line> Zone<'line> {
     pub fn from_str(input: &str) -> Result<Zone, Error> {
         if let Some(caps) = ZONE_LINE.captures(input) {
             let name = caps.name("name").unwrap().as_str();
-            let info = try!(ZoneInfo::from_captures(caps));
+            let info = ZoneInfo::from_captures(caps)?;
 
             Ok(Zone { name, info })
         }
@@ -321,18 +321,18 @@ pub struct ZoneInfo<'line> {
 
 impl<'line> ZoneInfo<'line> {
     fn from_captures(caps: Captures<'line>) -> Result<ZoneInfo<'line>, Error> {
-        let utc_offset    = try!(caps.name("gmtoff").unwrap().as_str().parse());
-        let saving        = try!(Saving::from_str(caps.name("rulessave").unwrap().as_str()));
+        let utc_offset    = caps.name("gmtoff").unwrap().as_str().parse()?;
+        let saving        = Saving::from_str(caps.name("rulessave").unwrap().as_str())?;
         let format        = caps.name("format").unwrap().as_str();
 
         // The year, month, day, and time fields are all optional, meaning
         // that it should be impossible to, say, have a defined month but not
         // a defined year.
         let time = match (caps.name("year"), caps.name("month"), caps.name("day"), caps.name("time")) {
-            (Some(y), Some(m), Some(d), Some(t)) => Some(ChangeTime::UntilTime  (try!(y.as_str().parse()), try!(m.as_str().parse()), try!(d.as_str().parse()), try!(t.as_str().parse()))),
-            (Some(y), Some(m), Some(d), _      ) => Some(ChangeTime::UntilDay   (try!(y.as_str().parse()), try!(m.as_str().parse()), try!(d.as_str().parse()))),
-            (Some(y), Some(m), _      , _      ) => Some(ChangeTime::UntilMonth (try!(y.as_str().parse()), try!(m.as_str().parse()))),
-            (Some(y), _      , _      , _      ) => Some(ChangeTime::UntilYear  (try!(y.as_str().parse()))),
+            (Some(y), Some(m), Some(d), Some(t)) => Some(ChangeTime::UntilTime  (y.as_str().parse()?, m.as_str().parse()?, d.as_str().parse()?, t.as_str().parse()?)),
+            (Some(y), Some(m), Some(d), _      ) => Some(ChangeTime::UntilDay   (y.as_str().parse()?, m.as_str().parse()?, d.as_str().parse()?)),
+            (Some(y), Some(m), _      , _      ) => Some(ChangeTime::UntilMonth (y.as_str().parse()?, m.as_str().parse()?)),
+            (Some(y), _      , _      , _      ) => Some(ChangeTime::UntilYear  (y.as_str().parse()?)),
             (None   , None   , None   , None   ) => None,
             _                                    => unreachable!("Out-of-order capturing groups!"),
         };
@@ -375,7 +375,7 @@ impl<'line> Saving<'line> {
             Ok(Saving::Multiple(input))
         }
         else if HM_FIELD.is_match(input) {
-            let time = try!(input.parse());
+            let time = input.parse()?;
             Ok(Saving::OneOff(time))
         }
         else {
@@ -624,7 +624,7 @@ impl FromStr for DaySpec {
         // Check if it stars with ‘last’, and trim off the first four bytes if
         // it does. (Luckily, the file is ASCII, so ‘last’ is four bytes)
         else if input.starts_with("last") {
-            let weekday = try!(input[4..].parse());
+            let weekday = input[4..].parse()?;
             Ok(DaySpec::Last(weekday))
         }
 
@@ -810,7 +810,7 @@ impl<'line> Line<'line> {
             Ok(Line::Zone(zone))
         }
         else if let Some(caps) = CONTINUATION_LINE.captures(input) {
-            Ok(Line::Continuation(try!(ZoneInfo::from_captures(caps))))
+            Ok(Line::Continuation(ZoneInfo::from_captures(caps)?))
         }
         else if let Ok(rule) = Rule::from_str(input) {
             Ok(Line::Rule(rule))
diff --git a/src/structure.rs b/src/structure.rs
index 994f18b..672c653 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -112,10 +112,7 @@ impl<'table> Iterator for Iter<'table> {
     type Item = TableStructureEntry<'table>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let key = match self.keys.pop() {
-            Some(k) => k,
-            None    => return None,
-        };
+        let key = self.keys.pop()?;
 
         // Move the strings out into an (automatically-sorted) vector.
         let values = self.structure.mappings[key].iter().cloned().collect();

From d20e50ea3a8fa7aa245c1fcb84fed83d75f1e753 Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:33:44 +0100
Subject: [PATCH 098/113] Fix some things Rust warns about now

---
 src/line.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index ab88261..5ea972b 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -87,10 +87,10 @@ use datetime::zone::TimeType;
 use regex::{Regex, Captures};
 
 
-/// A set of regexes to test against.
-///
-/// All of these regexes use the `(?x)` flag, which means they support
-/// comments and whitespace directly in the regex string!
+// A set of regexes to test against.
+//
+// All of these regexes use the `(?x)` flag, which means they support
+// comments and whitespace directly in the regex string!
 lazy_static! {
 
     /// Format of a Rule line: one capturing group per field.
@@ -590,7 +590,7 @@ impl DaySpec {
     /// Converts this day specification to a concrete date, given the year and
     /// month it should occur in.
     pub fn to_concrete_date(&self, year: i64, month: Month) -> LocalDate {
-        use datetime::{LocalDate, DatePiece, Year};
+        use datetime::{DatePiece, Year};
 
         match *self {
             DaySpec::Ordinal(day)           => LocalDate::ymd(year, month, day).unwrap(),

From a6cb3d4d38d64c7806be36a995c4638e6e099d7f Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:35:04 +0100
Subject: [PATCH 099/113] Move away from Error::description

---
 src/line.rs  | 8 ++------
 src/table.rs | 8 ++------
 2 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index 5ea972b..86b17c0 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -764,16 +764,12 @@ pub enum Error {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.description())
+        write!(f, "parse error")
     }
 }
 
 impl ErrorTrait for Error {
-    fn description(&self) -> &str {
-        "parse error"
-    }
-
-    fn cause(&self) -> Option<&ErrorTrait> {
+    fn cause(&self) -> Option<&dyn ErrorTrait> {
         None
     }
 }
diff --git a/src/table.rs b/src/table.rs
index 7848a25..57de001 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -401,16 +401,12 @@ pub enum Error<'line> {
 
 impl<'line> fmt::Display for Error<'line> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.description())
+        write!(f, "interpretation error")
     }
 }
 
 impl<'line> ErrorTrait for Error<'line> {
-    fn description(&self) -> &str {
-        "interpretation error"
-    }
-
-    fn cause(&self) -> Option<&ErrorTrait> {
+    fn cause(&self) -> Option<&dyn ErrorTrait> {
         None
     }
 }

From 486f2254cb4348318e4291cd0aa4a57655931e4c Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:36:51 +0100
Subject: [PATCH 100/113] Some more Clippy fixes

---
 src/line.rs        | 7 +------
 src/structure.rs   | 2 +-
 src/transitions.rs | 9 +++------
 3 files changed, 5 insertions(+), 13 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index 86b17c0..b473cf3 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -337,12 +337,7 @@ impl<'line> ZoneInfo<'line> {
             _                                    => unreachable!("Out-of-order capturing groups!"),
         };
 
-        Ok(ZoneInfo {
-            utc_offset:  utc_offset,
-            saving:      saving,
-            format:      format,
-            time:        time,
-        })
+        Ok(ZoneInfo { utc_offset, saving, format, time })
     }
 }
 
diff --git a/src/structure.rs b/src/structure.rs
index 672c653..1d710a1 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -74,7 +74,7 @@ impl Structure for Table {
             }
         }
 
-        TableStructure { mappings: mappings }
+        TableStructure { mappings }
     }
 }
 
diff --git a/src/transitions.rs b/src/transitions.rs
index 1969335..131e942 100644
--- a/src/transitions.rs
+++ b/src/transitions.rs
@@ -238,7 +238,7 @@ impl FixedTimespanSetBuilder {
             let timespan = FixedTimespan {
                 utc_offset: timespan.offset,
                 dst_offset: *dst_offset,
-                name:       start_zone_id.clone().unwrap_or("".to_owned()),
+                name:       start_zone_id.clone().unwrap_or_else(|| "".to_owned()),
             };
 
             self.rest.push((time, timespan));
@@ -248,7 +248,7 @@ impl FixedTimespanSetBuilder {
             self.first = Some(FixedTimespan {
                 utc_offset: utc_offset,
                 dst_offset: *dst_offset,
-                name:       start_zone_id.clone().unwrap_or("".to_owned()),
+                name:       start_zone_id.clone().unwrap_or_else(|| "".to_owned()),
             });
         }
     }
@@ -335,10 +335,7 @@ impl FixedTimespanSetBuilder {
             None     => self.rest.iter().find(|t| t.1.dst_offset == 0).unwrap().1.clone(),
         };
 
-        let mut zoneset = FixedTimespanSet {
-            first: first,
-            rest:  self.rest,
-        };
+        let mut zoneset = FixedTimespanSet { first, rest: self.rest };
         optimise(&mut zoneset);
         zoneset
     }

From 17c7dba4413070f01012c1ed15302cf7e9e7fdbd Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:38:35 +0100
Subject: [PATCH 101/113] Make two functions not take references

---
 src/line.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index b473cf3..9308c22 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -584,10 +584,10 @@ impl DaySpec {
 
     /// Converts this day specification to a concrete date, given the year and
     /// month it should occur in.
-    pub fn to_concrete_date(&self, year: i64, month: Month) -> LocalDate {
+    pub fn to_concrete_date(self, year: i64, month: Month) -> LocalDate {
         use datetime::{DatePiece, Year};
 
-        match *self {
+        match self {
             DaySpec::Ordinal(day)           => LocalDate::ymd(year, month, day).unwrap(),
             DaySpec::Last(w)                => DaySpec::find_weekday(w, Year(year).month(month).days(..).rev()),
             DaySpec::LastOnOrBefore(w, day) => DaySpec::find_weekday(w, Year(year).month(month).days(..).rev().filter(|d| d.day() < day)),
@@ -681,8 +681,8 @@ impl TimeSpec {
 
     /// Returns the number of seconds past midnight that this time spec
     /// represents.
-    pub fn as_seconds(&self) -> i64 {
-        match *self {
+    pub fn as_seconds(self) -> i64 {
+        match self {
             TimeSpec::Zero                         => 0,
             TimeSpec::Hours(h)                     => h as i64 * 3600,
             TimeSpec::HoursMinutes(h, m)           => h as i64 * 3600 + m as i64 * 60,

From 31bf6b188d1bbce8283ba8ca6a8dd884315c14aa Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:41:45 +0100
Subject: [PATCH 102/113] Use Self in a couple of places

---
 src/line.rs  | 10 +++++-----
 src/table.rs | 14 +++++++-------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index 9308c22..b023c83 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -510,7 +510,7 @@ impl FromStr for MonthSpec {
     type Err = Error;
 
     /// Attempts to parse the given string into a value of this type.
-    fn from_str(input: &str) -> Result<MonthSpec, Self::Err> {
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
         Ok(match &*input.to_ascii_lowercase() {
             "jan" | "january"    => MonthSpec(Month::January),
             "feb" | "february"   => MonthSpec(Month::February),
@@ -538,7 +538,7 @@ pub struct WeekdaySpec(pub Weekday);
 impl FromStr for WeekdaySpec {
     type Err = Error;
 
-    fn from_str(input: &str) -> Result<WeekdaySpec, Self::Err> {
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
 
         Ok(match &*input.to_ascii_lowercase() {
             "mon" | "monday"     => WeekdaySpec(Weekday::Monday),
@@ -609,7 +609,7 @@ impl DaySpec {
 impl FromStr for DaySpec {
     type Err = Error;
 
-    fn from_str(input: &str) -> Result<DaySpec, Self::Err> {
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
 
         // Parse the field as a number if it vaguely resembles one.
         if input.chars().all(|c| c.is_digit(10)) {
@@ -694,7 +694,7 @@ impl TimeSpec {
 impl FromStr for TimeSpecAndType {
     type Err = Error;
 
-    fn from_str(input: &str) -> Result<TimeSpecAndType, Self::Err> {
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
         if input == "-" {
             Ok(TimeSpecAndType(TimeSpec::Zero, TimeType::Wall))
         }
@@ -729,7 +729,7 @@ impl FromStr for TimeSpecAndType {
 impl FromStr for TimeSpec {
     type Err = Error;
 
-    fn from_str(input: &str) -> Result<TimeSpec, Self::Err> {
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
         match input.parse() {
             Ok(TimeSpecAndType(spec, TimeType::Wall)) => Ok(spec),
             Ok(TimeSpecAndType(_   , _             )) => Err(Error::Fail),
diff --git a/src/table.rs b/src/table.rs
index 57de001..109f353 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -112,8 +112,8 @@ pub struct RuleInfo {
 }
 
 impl<'line> From<line::Rule<'line>> for RuleInfo {
-    fn from(info: line::Rule) -> RuleInfo {
-        RuleInfo {
+    fn from(info: line::Rule) -> Self {
+        Self {
             from_year:    info.from_year,
             to_year:      info.to_year,
             month:        info.month,
@@ -184,8 +184,8 @@ pub struct ZoneInfo {
 }
 
 impl<'line> From<line::ZoneInfo<'line>> for ZoneInfo {
-    fn from(info: line::ZoneInfo) -> ZoneInfo {
-        ZoneInfo {
+    fn from(info: line::ZoneInfo) -> Self {
+        Self {
             offset: info.utc_offset.as_seconds(),
             saving: match info.saving {
                 line::Saving::NoSaving     => Saving::NoSaving,
@@ -250,7 +250,7 @@ impl Format {
     /// Convert the template into one of the `Format` variants. This can’t
     /// fail, as any syntax that doesn’t match one of the two formats will
     /// just be a ‘constant’ format.
-    pub fn new(template: &str) -> Format {
+    pub fn new(template: &str) -> Self {
         if let Some(pos) = template.find('/') {
             Format::Alternate {
                 standard:  template[.. pos].to_owned(),
@@ -306,8 +306,8 @@ pub struct TableBuilder {
 impl TableBuilder {
 
     /// Creates a new builder with an empty table.
-    pub fn new() -> TableBuilder {
-        TableBuilder {
+    pub fn new() -> Self {
+        Self {
             table: Table::default(),
             current_zoneset_name: None,
         }

From 8d74e9cc8d4b837bc864764a45d595a127cdd718 Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Wed, 8 Apr 2020 00:48:15 +0100
Subject: [PATCH 103/113] v0.5.0

---
 Cargo.toml | 4 ++--
 README.md  | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 0671270..50ae056 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,9 +8,9 @@ exclude = ["/README.md", "/LICENCE", "/.rustfmt.toml", "/.travis.yml"]
 license = "MIT"
 readme = "README.md"
 repository = "https://github.com/rust-datetime/zoneinfo-compiled"
-version = "0.1.4"
+version = "0.5.0"
 
 [dependencies]
-datetime = "0.4"
+datetime = "0.5"
 lazy_static = "1.4"
 regex = "1.3"
diff --git a/README.md b/README.md
index de51a30..bf90e6c 100644
--- a/README.md
+++ b/README.md
@@ -20,8 +20,8 @@ This crate works with [Cargo](https://crates.io). Add the following to your `Car
 
 ```toml
 [dependencies]
-datetime = "0.4"
-zoneinfo_parse = "0.1"
+datetime = "0.5"
+zoneinfo_parse = "0.5"
 ```
 
 The earliest version of Rust that this crate is tested against is [Rust v1.31.0](https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html).

From b794c598aa8567cafab4b8ed4b354fa7c40fd36c Mon Sep 17 00:00:00 2001
From: Dirkjan Ochtman <dirkjan@ochtman.nl>
Date: Mon, 15 Apr 2024 16:02:43 +0200
Subject: [PATCH 104/113] Move parse-zoneinfo into workspace

---
 Cargo.toml                                  | 15 ++-------------
 CHANGELOG.md => parse-zoneinfo/CHANGELOG.md |  0
 parse-zoneinfo/Cargo.toml                   | 13 +++++++++++++
 README.md => parse-zoneinfo/README.md       |  0
 {src => parse-zoneinfo/src}/lib.rs          |  0
 {src => parse-zoneinfo/src}/line.rs         |  0
 {src => parse-zoneinfo/src}/structure.rs    |  0
 {src => parse-zoneinfo/src}/table.rs        |  0
 {src => parse-zoneinfo/src}/transitions.rs  |  0
 9 files changed, 15 insertions(+), 13 deletions(-)
 rename CHANGELOG.md => parse-zoneinfo/CHANGELOG.md (100%)
 create mode 100644 parse-zoneinfo/Cargo.toml
 rename README.md => parse-zoneinfo/README.md (100%)
 rename {src => parse-zoneinfo/src}/lib.rs (100%)
 rename {src => parse-zoneinfo/src}/line.rs (100%)
 rename {src => parse-zoneinfo/src}/structure.rs (100%)
 rename {src => parse-zoneinfo/src}/table.rs (100%)
 rename {src => parse-zoneinfo/src}/transitions.rs (100%)

diff --git a/Cargo.toml b/Cargo.toml
index bfb4660..30cc4d4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,13 +1,2 @@
-[package]
-name = "parse-zoneinfo"
-version = "0.3.0"
-description = "Parse zoneinfo files from the IANA database"
-repository = "https://github.com/djzin/parse-zoneinfo"
-readme = "README.md"
-license = "MIT"
-keywords = ["date", "time", "timezone", "zone", "calendar"]
-
-[dependencies.regex]
-version = "1.3.1"
-default-features = false
-features = ["std", "unicode-perl"]
+[workspace]
+members = ["parse-zoneinfo"]
diff --git a/CHANGELOG.md b/parse-zoneinfo/CHANGELOG.md
similarity index 100%
rename from CHANGELOG.md
rename to parse-zoneinfo/CHANGELOG.md
diff --git a/parse-zoneinfo/Cargo.toml b/parse-zoneinfo/Cargo.toml
new file mode 100644
index 0000000..bfb4660
--- /dev/null
+++ b/parse-zoneinfo/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "parse-zoneinfo"
+version = "0.3.0"
+description = "Parse zoneinfo files from the IANA database"
+repository = "https://github.com/djzin/parse-zoneinfo"
+readme = "README.md"
+license = "MIT"
+keywords = ["date", "time", "timezone", "zone", "calendar"]
+
+[dependencies.regex]
+version = "1.3.1"
+default-features = false
+features = ["std", "unicode-perl"]
diff --git a/README.md b/parse-zoneinfo/README.md
similarity index 100%
rename from README.md
rename to parse-zoneinfo/README.md
diff --git a/src/lib.rs b/parse-zoneinfo/src/lib.rs
similarity index 100%
rename from src/lib.rs
rename to parse-zoneinfo/src/lib.rs
diff --git a/src/line.rs b/parse-zoneinfo/src/line.rs
similarity index 100%
rename from src/line.rs
rename to parse-zoneinfo/src/line.rs
diff --git a/src/structure.rs b/parse-zoneinfo/src/structure.rs
similarity index 100%
rename from src/structure.rs
rename to parse-zoneinfo/src/structure.rs
diff --git a/src/table.rs b/parse-zoneinfo/src/table.rs
similarity index 100%
rename from src/table.rs
rename to parse-zoneinfo/src/table.rs
diff --git a/src/transitions.rs b/parse-zoneinfo/src/transitions.rs
similarity index 100%
rename from src/transitions.rs
rename to parse-zoneinfo/src/transitions.rs

From 9c9a4f33cf09a0c7541d5377e4c9b73f67dff4d8 Mon Sep 17 00:00:00 2001
From: Benjamin Sago <ogham@bsago.me>
Date: Tue, 7 Apr 2020 23:21:55 +0100
Subject: [PATCH 105/113] Two fewer mutable variables

---
 parse-zoneinfo/src/table.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/parse-zoneinfo/src/table.rs b/parse-zoneinfo/src/table.rs
index e39073b..4a6412f 100644
--- a/parse-zoneinfo/src/table.rs
+++ b/parse-zoneinfo/src/table.rs
@@ -301,7 +301,7 @@ impl TableBuilder {
             }
         }
 
-        let zoneset: &mut _ = match self.table.zonesets.entry(zone_line.name.to_owned()) {
+        let zoneset = match self.table.zonesets.entry(zone_line.name.to_owned()) {
             Entry::Occupied(_) => return Err(Error::DuplicateZone),
             Entry::Vacant(e) => e.insert(Vec::new()),
         };
@@ -319,7 +319,7 @@ impl TableBuilder {
         &mut self,
         continuation_line: line::ZoneInfo,
     ) -> Result<(), Error> {
-        let zoneset: &mut _ = match self.current_zoneset_name {
+        let zoneset = match self.current_zoneset_name {
             Some(ref name) => self.table.zonesets.get_mut(name).unwrap(),
             None => return Err(Error::SurpriseContinuationLine),
         };

From c78711893ec15e070ccaa9d22cb13303d195640a Mon Sep 17 00:00:00 2001
From: Paul Dicker <paul@pitdicker.nl>
Date: Sun, 14 Apr 2024 14:57:08 +0200
Subject: [PATCH 106/113] Silence warnings for unused result of `mem::replace`

---
 parse-zoneinfo/src/transitions.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/parse-zoneinfo/src/transitions.rs b/parse-zoneinfo/src/transitions.rs
index 5769c24..5d6f2c1 100644
--- a/parse-zoneinfo/src/transitions.rs
+++ b/parse-zoneinfo/src/transitions.rs
@@ -334,9 +334,9 @@ impl FixedTimespanSetBuilder {
 
                 if *insert_start_transition {
                     if earliest_at < self.start_time.unwrap() {
-                        replace(start_utc_offset, timespan.offset);
-                        replace(start_dst_offset, *dst_offset);
-                        replace(
+                        let _ = replace(start_utc_offset, timespan.offset);
+                        let _ = replace(start_dst_offset, *dst_offset);
+                        let _ = replace(
                             start_zone_id,
                             Some(
                                 timespan
@@ -350,7 +350,7 @@ impl FixedTimespanSetBuilder {
                     if start_zone_id.is_none()
                         && *start_utc_offset + *start_dst_offset == timespan.offset + *dst_offset
                     {
-                        replace(
+                        let _ = replace(
                             start_zone_id,
                             Some(
                                 timespan

From 5df241a43077d8ef4e1566b150d56e53120105db Mon Sep 17 00:00:00 2001
From: Paul Dicker <paul@pitdicker.nl>
Date: Sun, 14 Apr 2024 14:17:45 +0200
Subject: [PATCH 107/113] Update to rust 2021

---
 parse-zoneinfo/Cargo.toml         | 2 ++
 parse-zoneinfo/src/lib.rs         | 2 --
 parse-zoneinfo/src/structure.rs   | 4 ++--
 parse-zoneinfo/src/table.rs       | 9 +--------
 parse-zoneinfo/src/transitions.rs | 2 +-
 5 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/parse-zoneinfo/Cargo.toml b/parse-zoneinfo/Cargo.toml
index bfb4660..db0a966 100644
--- a/parse-zoneinfo/Cargo.toml
+++ b/parse-zoneinfo/Cargo.toml
@@ -1,6 +1,8 @@
 [package]
 name = "parse-zoneinfo"
 version = "0.3.0"
+edition = "2021"
+rust-version = "1.56.0"
 description = "Parse zoneinfo files from the IANA database"
 repository = "https://github.com/djzin/parse-zoneinfo"
 readme = "README.md"
diff --git a/parse-zoneinfo/src/lib.rs b/parse-zoneinfo/src/lib.rs
index 64a1d0a..bfcfd7f 100644
--- a/parse-zoneinfo/src/lib.rs
+++ b/parse-zoneinfo/src/lib.rs
@@ -34,8 +34,6 @@
 #![warn(unreachable_pub)]
 #![warn(unused)]
 
-extern crate regex;
-
 pub mod line;
 pub mod structure;
 pub mod table;
diff --git a/parse-zoneinfo/src/structure.rs b/parse-zoneinfo/src/structure.rs
index 1eb2d0d..e8e604b 100644
--- a/parse-zoneinfo/src/structure.rs
+++ b/parse-zoneinfo/src/structure.rs
@@ -32,7 +32,7 @@
 
 use std::collections::{BTreeMap, BTreeSet};
 
-use table::Table;
+use crate::table::Table;
 
 /// Trait to put the `structure` method on Tables.
 pub trait Structure {
@@ -150,7 +150,7 @@ pub enum Child<'table> {
 #[allow(unused_results)]
 mod test {
     use super::*;
-    use table::Table;
+    use crate::table::Table;
 
     #[test]
     fn empty() {
diff --git a/parse-zoneinfo/src/table.rs b/parse-zoneinfo/src/table.rs
index 4a6412f..318d9b2 100644
--- a/parse-zoneinfo/src/table.rs
+++ b/parse-zoneinfo/src/table.rs
@@ -38,9 +38,7 @@ use std::collections::hash_map::{Entry, HashMap};
 use std::error::Error as ErrorTrait;
 use std::fmt;
 
-use line::{self, ChangeTime, DaySpec, Month, Year};
-
-use crate::line::TimeType;
+use crate::line::{self, ChangeTime, DaySpec, Month, TimeType, Year};
 
 /// A **table** of all the data in one or more zoneinfo files.
 #[derive(PartialEq, Debug, Default)]
@@ -392,9 +390,4 @@ impl<'line> ErrorTrait for Error<'line> {
     fn description(&self) -> &str {
         "interpretation error"
     }
-
-    #[allow(bare_trait_objects)] // remove when we require edition 2018
-    fn cause(&self) -> Option<&ErrorTrait> {
-        None
-    }
 }
diff --git a/parse-zoneinfo/src/transitions.rs b/parse-zoneinfo/src/transitions.rs
index 5d6f2c1..61178c4 100644
--- a/parse-zoneinfo/src/transitions.rs
+++ b/parse-zoneinfo/src/transitions.rs
@@ -101,7 +101,7 @@
 //! The logic in this file is based off of `zic.c`, which comes with the
 //! zoneinfo files and is in the public domain.
 
-use table::{RuleInfo, Saving, Table, ZoneInfo};
+use crate::table::{RuleInfo, Saving, Table, ZoneInfo};
 
 /// A set of timespans, separated by the instances at which the timespans
 /// change over. There will always be one more timespan than transitions.

From 61557cd5407e494770285d1925d64c42973f5db0 Mon Sep 17 00:00:00 2001
From: Paul Dicker <paul@pitdicker.nl>
Date: Sun, 14 Apr 2024 15:20:05 +0200
Subject: [PATCH 108/113] Implement `Default` for `LineParser`

---
 parse-zoneinfo/src/line.rs | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/parse-zoneinfo/src/line.rs b/parse-zoneinfo/src/line.rs
index 3302bed..b969daa 100644
--- a/parse-zoneinfo/src/line.rs
+++ b/parse-zoneinfo/src/line.rs
@@ -18,7 +18,7 @@
 //! # fn main() {
 //! use parse_zoneinfo::line::*;
 //!
-//! let parser = LineParser::new();
+//! let parser = LineParser::default();
 //! let line = parser.parse_str("Rule  EU  1977    1980    -   Apr Sun>=1   1:00u  1:00    S");
 //!
 //! assert_eq!(line, Ok(Line::Rule(Rule {
@@ -40,7 +40,7 @@
 //! # fn main() {
 //! use parse_zoneinfo::line::*;
 //!
-//! let parser = LineParser::new();
+//! let parser = LineParser::default();
 //! let line = parser.parse_str("Zone  Australia/Adelaide  9:30  Aus  AC%sT  1971 Oct 31  2:00:00");
 //!
 //! assert_eq!(line, Ok(Line::Zone(Zone {
@@ -65,7 +65,7 @@
 //! ```
 //! use parse_zoneinfo::line::*;
 //!
-//! let parser = LineParser::new();
+//! let parser = LineParser::default();
 //! let line = parser.parse_str("Link  Europe/Istanbul  Asia/Istanbul");
 //! assert_eq!(line, Ok(Line::Link(Link {
 //!     existing:  "Europe/Istanbul",
@@ -107,8 +107,8 @@ pub enum Error {
     NotParsedAsLinkLine,
 }
 
-impl LineParser {
-    pub fn new() -> Self {
+impl Default for LineParser {
+    fn default() -> Self {
         LineParser {
             rule_line: Regex::new(
                 r##"(?x) ^
@@ -969,6 +969,11 @@ fn parse_time_type(c: &str) -> Option<TimeType> {
 }
 
 impl LineParser {
+    #[deprecated]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
     fn parse_timespec_and_type(&self, input: &str) -> Result<TimeSpecAndType, Error> {
         if input == "-" {
             Ok(TimeSpecAndType(TimeSpec::Zero, TimeType::Wall))
@@ -1222,7 +1227,7 @@ mod tests {
         ($name:ident: $input:expr => $result:expr) => {
             #[test]
             fn $name() {
-                let parser = LineParser::new();
+                let parser = LineParser::default();
                 assert_eq!(parser.parse_str($input), $result);
             }
         };
@@ -1304,7 +1309,7 @@ mod tests {
     #[test]
     fn negative_offsets() {
         static LINE: &'static str = "Zone    Europe/London   -0:01:15 -  LMT 1847 Dec  1  0:00s";
-        let parser = LineParser::new();
+        let parser = LineParser::default();
         let zone = parser.parse_zone(LINE).unwrap();
         assert_eq!(
             zone.info.utc_offset,
@@ -1316,7 +1321,7 @@ mod tests {
     fn negative_offsets_2() {
         static LINE: &'static str =
             "Zone        Europe/Madrid   -0:14:44 -      LMT     1901 Jan  1  0:00s";
-        let parser = LineParser::new();
+        let parser = LineParser::default();
         let zone = parser.parse_zone(LINE).unwrap();
         assert_eq!(
             zone.info.utc_offset,
@@ -1327,7 +1332,7 @@ mod tests {
     #[test]
     fn negative_offsets_3() {
         static LINE: &'static str = "Zone America/Danmarkshavn -1:14:40 -    LMT 1916 Jul 28";
-        let parser = LineParser::new();
+        let parser = LineParser::default();
         let zone = parser.parse_zone(LINE).unwrap();
         assert_eq!(
             zone.info.utc_offset,

From e4bda756627cf507b9daa5901317023060da046a Mon Sep 17 00:00:00 2001
From: Paul Dicker <paul@pitdicker.nl>
Date: Mon, 15 Apr 2024 16:06:47 +0200
Subject: [PATCH 109/113] Apply clippy fixes

---
 examples/benchmark.rs             |  6 +++--
 parse-zoneinfo/src/line.rs        | 43 ++++++++++++++-----------------
 parse-zoneinfo/src/structure.rs   |  6 ++---
 parse-zoneinfo/src/table.rs       | 10 +++++--
 parse-zoneinfo/src/transitions.rs | 13 +++++-----
 tests/transition_tests.rs         |  2 +-
 6 files changed, 43 insertions(+), 37 deletions(-)

diff --git a/examples/benchmark.rs b/examples/benchmark.rs
index 2bec4eb..8b39a3d 100644
--- a/examples/benchmark.rs
+++ b/examples/benchmark.rs
@@ -8,7 +8,9 @@ use parse_zoneinfo::table::TableBuilder;
 // ignored in this case, however this never happens in the tz database as it
 // stands.
 fn strip_comments(mut line: String) -> String {
-    line.find('#').map(|pos| line.truncate(pos));
+    if let Some(pos) = line.find('#') {
+        line.truncate(pos)
+    }
     line
 }
 
@@ -23,7 +25,7 @@ fn main() {
         let parser = LineParser::new();
         let mut builder = TableBuilder::new();
         for line in &lines {
-            match parser.parse_str(&line).unwrap() {
+            match parser.parse_str(line).unwrap() {
                 Line::Zone(zone) => builder.add_zone_line(zone).unwrap(),
                 Line::Continuation(cont) => builder.add_continuation_line(cont).unwrap(),
                 Line::Rule(rule) => builder.add_rule_line(rule).unwrap(),
diff --git a/parse-zoneinfo/src/line.rs b/parse-zoneinfo/src/line.rs
index b969daa..725fdca 100644
--- a/parse-zoneinfo/src/line.rs
+++ b/parse-zoneinfo/src/line.rs
@@ -977,7 +977,7 @@ impl LineParser {
     fn parse_timespec_and_type(&self, input: &str) -> Result<TimeSpecAndType, Error> {
         if input == "-" {
             Ok(TimeSpecAndType(TimeSpec::Zero, TimeType::Wall))
-        } else if input.chars().all(|c| c == '-' || c.is_digit(10)) {
+        } else if input.chars().all(|c| c == '-' || c.is_ascii_digit()) {
             Ok(TimeSpecAndType(
                 TimeSpec::Hours(input.parse().unwrap()),
                 TimeType::Wall,
@@ -1032,13 +1032,13 @@ impl LineParser {
 
     fn parse_dayspec(&self, input: &str) -> Result<DaySpec, Error> {
         // Parse the field as a number if it vaguely resembles one.
-        if input.chars().all(|c| c.is_digit(10)) {
+        if input.chars().all(|c| c.is_ascii_digit()) {
             Ok(DaySpec::Ordinal(input.parse().unwrap()))
         }
         // Check if it stars with ‘last’, and trim off the first four bytes if
         // it does. (Luckily, the file is ASCII, so ‘last’ is four bytes)
-        else if input.starts_with("last") {
-            let weekday = input[4..].parse()?;
+        else if let Some(remainder) = input.strip_prefix("last") {
+            let weekday = remainder.parse()?;
             Ok(DaySpec::Last(weekday))
         }
         // Check if it’s a relative expression with the regex.
@@ -1090,14 +1090,14 @@ impl LineParser {
             };
 
             Ok(Rule {
-                name: name,
-                from_year: from_year,
-                to_year: to_year,
-                month: month,
-                day: day,
-                time: time,
-                time_to_add: time_to_add,
-                letters: letters,
+                name,
+                from_year,
+                to_year,
+                month,
+                day,
+                time,
+                time_to_add,
+                letters,
             })
         } else {
             Err(Error::NotParsedAsRuleLine)
@@ -1155,10 +1155,10 @@ impl LineParser {
         };
 
         Ok(ZoneInfo {
-            utc_offset: utc_offset,
-            saving: saving,
-            format: format,
-            time: time,
+            utc_offset,
+            saving,
+            format,
+            time,
         })
     }
 
@@ -1166,10 +1166,7 @@ impl LineParser {
         if let Some(caps) = self.zone_line.captures(input) {
             let name = caps.name("name").unwrap().as_str();
             let info = self.zoneinfo_from_captures(caps)?;
-            Ok(Zone {
-                name: name,
-                info: info,
-            })
+            Ok(Zone { name, info })
         } else {
             Err(Error::NotParsedAsZoneLine)
         }
@@ -1308,7 +1305,7 @@ mod tests {
 
     #[test]
     fn negative_offsets() {
-        static LINE: &'static str = "Zone    Europe/London   -0:01:15 -  LMT 1847 Dec  1  0:00s";
+        static LINE: &str = "Zone    Europe/London   -0:01:15 -  LMT 1847 Dec  1  0:00s";
         let parser = LineParser::default();
         let zone = parser.parse_zone(LINE).unwrap();
         assert_eq!(
@@ -1319,7 +1316,7 @@ mod tests {
 
     #[test]
     fn negative_offsets_2() {
-        static LINE: &'static str =
+        static LINE: &str =
             "Zone        Europe/Madrid   -0:14:44 -      LMT     1901 Jan  1  0:00s";
         let parser = LineParser::default();
         let zone = parser.parse_zone(LINE).unwrap();
@@ -1331,7 +1328,7 @@ mod tests {
 
     #[test]
     fn negative_offsets_3() {
-        static LINE: &'static str = "Zone America/Danmarkshavn -1:14:40 -    LMT 1916 Jul 28";
+        static LINE: &str = "Zone America/Danmarkshavn -1:14:40 -    LMT 1916 Jul 28";
         let parser = LineParser::default();
         let zone = parser.parse_zone(LINE).unwrap();
         assert_eq!(
diff --git a/parse-zoneinfo/src/structure.rs b/parse-zoneinfo/src/structure.rs
index e8e604b..2a47c5b 100644
--- a/parse-zoneinfo/src/structure.rs
+++ b/parse-zoneinfo/src/structure.rs
@@ -179,7 +179,7 @@ mod test {
         assert_eq!(
             structure.next(),
             Some(TableStructureEntry {
-                name: &"a".to_owned(),
+                name: "a",
                 children: vec![Child::TimeZone("b")]
             })
         );
@@ -197,14 +197,14 @@ mod test {
         assert_eq!(
             structure.next(),
             Some(TableStructureEntry {
-                name: &"a".to_owned(),
+                name: "a",
                 children: vec![Child::Submodule("b"), Child::TimeZone("e")]
             })
         );
         assert_eq!(
             structure.next(),
             Some(TableStructureEntry {
-                name: &"a/b".to_owned(),
+                name: "a/b",
                 children: vec![Child::TimeZone("c"), Child::TimeZone("d")]
             })
         );
diff --git a/parse-zoneinfo/src/table.rs b/parse-zoneinfo/src/table.rs
index 318d9b2..0de5682 100644
--- a/parse-zoneinfo/src/table.rs
+++ b/parse-zoneinfo/src/table.rs
@@ -61,7 +61,7 @@ impl Table {
             Some(&*self.zonesets[zone_name])
         } else if self.links.contains_key(zone_name) {
             let target = &self.links[zone_name];
-            Some(&*self.zonesets[&*target])
+            Some(&*self.zonesets[target])
         } else {
             None
         }
@@ -276,6 +276,12 @@ pub struct TableBuilder {
     current_zoneset_name: Option<String>,
 }
 
+impl Default for TableBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl TableBuilder {
     /// Creates a new builder with an empty table.
     pub fn new() -> TableBuilder {
@@ -333,7 +339,7 @@ impl TableBuilder {
             .table
             .rulesets
             .entry(rule_line.name.to_owned())
-            .or_insert_with(Vec::new);
+            .or_default();
 
         ruleset.push(rule_line.into());
         self.current_zoneset_name = None;
diff --git a/parse-zoneinfo/src/transitions.rs b/parse-zoneinfo/src/transitions.rs
index 61178c4..d8b3805 100644
--- a/parse-zoneinfo/src/transitions.rs
+++ b/parse-zoneinfo/src/transitions.rs
@@ -197,10 +197,10 @@ impl TableTransitions for Table {
                 }
 
                 Saving::Multiple(ref rules) => {
-                    let rules = &self.rulesets[&*rules];
+                    let rules = &self.rulesets[rules];
                     builder.add_multiple_saving(
                         zone_info,
-                        &*rules,
+                        rules,
                         &mut dst_offset,
                         use_until,
                         utc_offset,
@@ -262,21 +262,22 @@ impl FixedTimespanSetBuilder {
             let timespan = FixedTimespan {
                 utc_offset: timespan.offset,
                 dst_offset: *dst_offset,
-                name: start_zone_id.clone().unwrap_or_else(String::new),
+                name: start_zone_id.clone().unwrap_or_default(),
             };
 
             self.rest.push((time, timespan));
             *insert_start_transition = false;
         } else {
             self.first = Some(FixedTimespan {
-                utc_offset: utc_offset,
+                utc_offset,
                 dst_offset: *dst_offset,
-                name: start_zone_id.clone().unwrap_or_else(String::new),
+                name: start_zone_id.clone().unwrap_or_default(),
             });
         }
     }
 
     #[allow(unused_results)]
+    #[allow(clippy::too_many_arguments)]
     fn add_multiple_saving(
         &mut self,
         timespan: &ZoneInfo,
@@ -391,7 +392,7 @@ impl FixedTimespanSetBuilder {
         };
 
         let mut zoneset = FixedTimespanSet {
-            first: first,
+            first,
             rest: self.rest,
         };
         optimise(&mut zoneset);
diff --git a/tests/transition_tests.rs b/tests/transition_tests.rs
index 78a646e..0a75e23 100644
--- a/tests/transition_tests.rs
+++ b/tests/transition_tests.rs
@@ -801,7 +801,7 @@ fn tripoli() {
 
 #[test]
 fn dushanbe() {
-    static ZONEINFO: &'static str = r#"
+    static ZONEINFO: &str = r#"
 Zone    Asia/Dushanbe   4:35:12 -   LMT 1924 May  2
             5:00    1:00    +05/+06 1991 Sep  9  2:00s
 "#;

From 56887a92087764d7f4f39fb55618705ec44188f3 Mon Sep 17 00:00:00 2001
From: Paul Dicker <paul@pitdicker.nl>
Date: Sun, 14 Apr 2024 14:40:20 +0200
Subject: [PATCH 110/113] Implement `std::error::Error`

---
 parse-zoneinfo/src/line.rs  | 30 ++++++++++++++++++++++++++++++
 parse-zoneinfo/src/table.rs | 19 ++++++++++++-------
 2 files changed, 42 insertions(+), 7 deletions(-)

diff --git a/parse-zoneinfo/src/line.rs b/parse-zoneinfo/src/line.rs
index 725fdca..2fb0c10 100644
--- a/parse-zoneinfo/src/line.rs
+++ b/parse-zoneinfo/src/line.rs
@@ -73,6 +73,7 @@
 //! })));
 //! ```
 
+use std::fmt;
 use std::str::FromStr;
 // we still support rust that doesn't have the inherent methods
 #[allow(deprecated, unused_imports)]
@@ -107,6 +108,35 @@ pub enum Error {
     NotParsedAsLinkLine,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Error::FailedYearParse(s) => write!(f, "failed to parse as a year value: \"{}\"", s),
+            Error::FailedMonthParse(s) => write!(f, "failed to parse as a month value: \"{}\"", s),
+            Error::FailedWeekdayParse(s) => {
+                write!(f, "failed to parse as a weekday value: \"{}\"", s)
+            }
+            Error::InvalidLineType(s) => write!(f, "line with invalid format: \"{}\"", s),
+            Error::TypeColumnContainedNonHyphen(s) => write!(
+                f,
+                "'type' column is not a hyphen but has the value: \"{}\"",
+                s
+            ),
+            Error::CouldNotParseSaving(s) => write!(f, "failed to parse RULES column: \"{}\"", s),
+            Error::InvalidDaySpec(s) => write!(f, "invalid day specification ('ON'): \"{}\"", s),
+            Error::InvalidTimeSpecAndType(s) => write!(f, "invalid time: \"{}\"", s),
+            Error::NonWallClockInTimeSpec(s) => {
+                write!(f, "time value not given as wall time: \"{}\"", s)
+            }
+            Error::NotParsedAsRuleLine => write!(f, "failed to parse line as a rule"),
+            Error::NotParsedAsZoneLine => write!(f, "failed to parse line as a zone"),
+            Error::NotParsedAsLinkLine => write!(f, "failed to parse line as a link"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
 impl Default for LineParser {
     fn default() -> Self {
         LineParser {
diff --git a/parse-zoneinfo/src/table.rs b/parse-zoneinfo/src/table.rs
index 0de5682..05dee78 100644
--- a/parse-zoneinfo/src/table.rs
+++ b/parse-zoneinfo/src/table.rs
@@ -35,7 +35,6 @@
 //! ```
 
 use std::collections::hash_map::{Entry, HashMap};
-use std::error::Error as ErrorTrait;
 use std::fmt;
 
 use crate::line::{self, ChangeTime, DaySpec, Month, TimeType, Year};
@@ -388,12 +387,18 @@ pub enum Error<'line> {
 
 impl<'line> fmt::Display for Error<'line> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.description())
+        match self {
+            Error::SurpriseContinuationLine => write!(
+                f,
+                "continuation line follows line that isn't a zone definition line"
+            ),
+            Error::UnknownRuleset(_) => {
+                write!(f, "zone definition refers to a ruleset that isn't defined")
+            }
+            Error::DuplicateLink(_) => write!(f, "link line with name that already exists"),
+            Error::DuplicateZone => write!(f, "zone line with name that already exists"),
+        }
     }
 }
 
-impl<'line> ErrorTrait for Error<'line> {
-    fn description(&self) -> &str {
-        "interpretation error"
-    }
-}
+impl<'line> std::error::Error for Error<'line> {}

From 31072df07c4a80b7f8d1d25a810447eb00767054 Mon Sep 17 00:00:00 2001
From: Paul Dicker <paul@pitdicker.nl>
Date: Sun, 14 Apr 2024 13:47:48 +0200
Subject: [PATCH 111/113] Update example in `table` module

---
 parse-zoneinfo/src/line.rs  |  4 ++--
 parse-zoneinfo/src/table.rs | 24 +++++++++++++++++-------
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/parse-zoneinfo/src/line.rs b/parse-zoneinfo/src/line.rs
index 2fb0c10..6a69a6a 100644
--- a/parse-zoneinfo/src/line.rs
+++ b/parse-zoneinfo/src/line.rs
@@ -1192,7 +1192,7 @@ impl LineParser {
         })
     }
 
-    pub fn parse_zone<'a>(&self, input: &'a str) -> Result<Zone<'a>, Error> {
+    fn parse_zone<'a>(&self, input: &'a str) -> Result<Zone<'a>, Error> {
         if let Some(caps) = self.zone_line.captures(input) {
             let name = caps.name("name").unwrap().as_str();
             let info = self.zoneinfo_from_captures(caps)?;
@@ -1202,7 +1202,7 @@ impl LineParser {
         }
     }
 
-    pub fn parse_link<'a>(&self, input: &'a str) -> Result<Link<'a>, Error> {
+    fn parse_link<'a>(&self, input: &'a str) -> Result<Link<'a>, Error> {
         if let Some(caps) = self.link_line.captures(input) {
             let target = caps.name("target").unwrap().as_str();
             let name = caps.name("name").unwrap().as_str();
diff --git a/parse-zoneinfo/src/table.rs b/parse-zoneinfo/src/table.rs
index 05dee78..f91c166 100644
--- a/parse-zoneinfo/src/table.rs
+++ b/parse-zoneinfo/src/table.rs
@@ -17,21 +17,31 @@
 //! ## Example
 //!
 //! ```
-//! use parse_zoneinfo::line::{Zone, Link, LineParser};
+//! use parse_zoneinfo::line::{Zone, Line, LineParser, Link};
 //! use parse_zoneinfo::table::{TableBuilder};
 //!
-//! let parser = LineParser::new();
-//! let zone = parser.parse_zone("Zone  Pacific/Auckland  11:39:04  -  LMT  1868  Nov  2").unwrap();
-//! let link = parser.parse_link("Link  Pacific/Auckland  Antarctica/McMurdo").unwrap();
-//!
+//! let parser = LineParser::default();
 //! let mut builder = TableBuilder::new();
-//! builder.add_zone_line(zone).unwrap();
-//! builder.add_link_line(link).unwrap();
+//!
+//! let zone = "Zone  Pacific/Auckland  11:39:04  -  LMT  1868  Nov  2";
+//! let link = "Link  Pacific/Auckland  Antarctica/McMurdo";
+//!
+//! for line in [zone, link] {
+//!     match parser.parse_str(&line)? {
+//!         Line::Zone(zone) => builder.add_zone_line(zone).unwrap(),
+//!         Line::Continuation(cont) => builder.add_continuation_line(cont).unwrap(),
+//!         Line::Rule(rule) => builder.add_rule_line(rule).unwrap(),
+//!         Line::Link(link) => builder.add_link_line(link).unwrap(),
+//!         Line::Space => {}
+//!     }
+//! }
+//!
 //! let table = builder.build();
 //!
 //! assert!(table.get_zoneset("Pacific/Auckland").is_some());
 //! assert!(table.get_zoneset("Antarctica/McMurdo").is_some());
 //! assert!(table.get_zoneset("UTC").is_none());
+//! # Ok::<(), parse_zoneinfo::line::Error>(())
 //! ```
 
 use std::collections::hash_map::{Entry, HashMap};

From 67dc9ea2dd2dbd2b80dd81853481d851d6eda1a0 Mon Sep 17 00:00:00 2001
From: Paul Dicker <paul@pitdicker.nl>
Date: Mon, 15 Apr 2024 16:12:55 +0200
Subject: [PATCH 112/113] Remove `fn main` from doctests

---
 parse-zoneinfo/src/line.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/parse-zoneinfo/src/line.rs b/parse-zoneinfo/src/line.rs
index 6a69a6a..abaf608 100644
--- a/parse-zoneinfo/src/line.rs
+++ b/parse-zoneinfo/src/line.rs
@@ -14,8 +14,6 @@
 //! Parsing a `Rule` line:
 //!
 //! ```
-//! # extern crate parse_zoneinfo;
-//! # fn main() {
 //! use parse_zoneinfo::line::*;
 //!
 //! let parser = LineParser::default();
@@ -31,13 +29,11 @@
 //!     time_to_add:  TimeSpec::HoursMinutes(1, 0),
 //!     letters:      Some("S"),
 //! })));
-//! # }
 //! ```
 //!
 //! Parsing a `Zone` line:
 //!
 //! ```
-//! # fn main() {
 //! use parse_zoneinfo::line::*;
 //!
 //! let parser = LineParser::default();
@@ -57,7 +53,6 @@
 //!                      ),
 //!     },
 //! })));
-//! # }
 //! ```
 //!
 //! Parsing a `Link` line:

From 0207cf40ee9525c029399571561f47ddbf7cbad2 Mon Sep 17 00:00:00 2001
From: Paul Dicker <paul@pitdicker.nl>
Date: Sun, 14 Apr 2024 16:57:27 +0200
Subject: [PATCH 113/113] Make regex for UNTIL column more precise to parse
 comments correctly

---
 parse-zoneinfo/src/line.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/parse-zoneinfo/src/line.rs b/parse-zoneinfo/src/line.rs
index abaf608..2f12d9a 100644
--- a/parse-zoneinfo/src/line.rs
+++ b/parse-zoneinfo/src/line.rs
@@ -182,14 +182,14 @@ impl Default for LineParser {
             zone_line: Regex::new(
                 r##"(?x) ^
                 Zone \s+
-                ( ?P<name> [ A-Z a-z 0-9 / _ + - ]+ )  \s+
+                ( ?P<name> [A-Za-z0-9/_+-]+ )  \s+
                 ( ?P<gmtoff>     \S+ )  \s+
                 ( ?P<rulessave>  \S+ )  \s+
                 ( ?P<format>     \S+ )  \s*
-                ( ?P<year>       \S+ )? \s*
-                ( ?P<month>      \S+ )? \s*
-                ( ?P<day>        \S+ )? \s*
-                ( ?P<time>       \S+ )? \s*
+                ( ?P<year>       [0-9]+)? \s*
+                ( ?P<month>      [A-Za-z]+)? \s*
+                ( ?P<day>        [A-Za-z0-9><=]+ )? \s*
+                ( ?P<time>       [0-9:]+[suwz]? )? \s*
                 (\#.*)?
             $ "##,
             )
@@ -201,10 +201,10 @@ impl Default for LineParser {
                 ( ?P<gmtoff>     \S+ )  \s+
                 ( ?P<rulessave>  \S+ )  \s+
                 ( ?P<format>     \S+ )  \s*
-                ( ?P<year>       \S+ )? \s*
-                ( ?P<month>      \S+ )? \s*
-                ( ?P<day>        \S+ )? \s*
-                ( ?P<time>       \S+ )? \s*
+                ( ?P<year>       [0-9]+)? \s*
+                ( ?P<month>      [A-Za-z]+)? \s*
+                ( ?P<day>        [A-Za-z0-9><=]+ )? \s*
+                ( ?P<time>       [0-9:]+[suwz]? )? \s*
                 (\#.*)?
             $ "##,
             )