LibTimeZone: Parse ZONE entries from the TZDB and generate their names

Meta/Lagom/Tools/CodeGenerators/LibTimeZone/GenerateTimeZoneData.cpp

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include "../LibUnicode/GeneratorUtil.h" // FIXME: Move this somewhere common.
+#include <AK/HashMap.h>
 #include <AK/SourceGenerator.h>
 #include <AK/String.h>
 #include <AK/StringBuilder.h>
@@ -11,25 +13,218 @@
 #include <LibCore/ArgsParser.h>
 #include <LibCore/File.h>
 
-static void generate_time_zone_data_header(Core::File& file)
+struct Time {
+    i8 hour { 0 };
+    u8 minute { 0 };
+    u8 second { 0 };
+};
+
+struct DateTime {
+    u16 year { 0 };
+    Optional<u8> month;
+    Optional<u8> last_weekday;
+    Optional<u8> after_weekday;
+    Optional<u8> day;
+    Optional<Time> time;
+};
+
+struct TimeZone {
+    Time offset;
+    Optional<DateTime> until;
+};
+
+struct TimeZoneData {
+    HashMap<String, Vector<TimeZone>> time_zones;
+    Vector<String> time_zones_names;
+};
+
+static Time parse_time(StringView segment)
+{
+    // FIXME: Some times end with a letter, e.g. "2:00u" and "2:00s". Figure out what this means and handle it.
+    auto segments = segment.split_view(':');
+
+    Time time {};
+    time.hour = segments[0].to_int().value();
+    time.minute = segments.size() > 1 ? segments[1].substring_view(0, 2).to_uint().value() : 0;
+    time.second = segments.size() > 2 ? segments[2].substring_view(0, 2).to_uint().value() : 0;
+
+    return time;
+}
+
+static Optional<DateTime> parse_date_time(Span<StringView const> segments)
+{
+    constexpr auto months = Array { "Jan"sv, "Feb"sv, "Mar"sv, "Apr"sv, "May"sv, "Jun"sv, "Jul"sv, "Aug"sv, "Sep"sv, "Oct"sv, "Nov"sv, "Dec"sv };
+    constexpr auto weekdays = Array { "Sun"sv, "Mon"sv, "Tue"sv, "Wed"sv, "Thu"sv, "Fri"sv, "Sat"sv };
+
+    auto comment_index = find_index(segments.begin(), segments.end(), "#"sv);
+    if (comment_index != segments.size())
+        segments = segments.slice(0, comment_index);
+    if (segments.is_empty())
+        return {};
+
+    DateTime date_time {};
+    date_time.year = segments[0].to_uint().value();
+
+    if (segments.size() > 1)
+        date_time.month = find_index(months.begin(), months.end(), segments[1]);
+
+    if (segments.size() > 2) {
+        if (segments[2].starts_with("last"sv)) {
+            auto weekday = segments[2].substring_view("last"sv.length());
+            date_time.last_weekday = find_index(weekdays.begin(), weekdays.end(), weekday);
+        } else if (auto index = segments[2].find(">="sv); index.has_value()) {
+            auto weekday = segments[2].substring_view(0, *index);
+            date_time.after_weekday = find_index(weekdays.begin(), weekdays.end(), weekday);
+
+            auto day = segments[2].substring_view(*index + ">="sv.length());
+            date_time.day = day.to_uint().value();
+        } else {
+            date_time.day = segments[2].to_uint().value();
+        }
+    }
+
+    if (segments.size() > 3)
+        date_time.time = parse_time(segments[3]);
+
+    return date_time;
+}
+
+static Vector<TimeZone>& parse_zone(StringView zone_line, TimeZoneData& time_zone_data)
+{
+    auto segments = zone_line.split_view_if([](char ch) { return (ch == '\t') || (ch == ' '); });
+
+    // "Zone" NAME STDOFF RULES FORMAT [UNTIL]
+    VERIFY(segments[0] == "Zone"sv);
+    auto name = segments[1];
+
+    TimeZone time_zone {};
+    time_zone.offset = parse_time(segments[2]);
+
+    if (segments.size() > 5)
+        time_zone.until = parse_date_time(segments.span().slice(5));
+
+    auto& time_zones = time_zone_data.time_zones.ensure(name);
+    time_zones.append(move(time_zone));
+
+    if (!time_zone_data.time_zones_names.contains_slow(name))
+        time_zone_data.time_zones_names.append(name);
+
+    return time_zones;
+}
+
+static void parse_zone_continuation(StringView zone_line, Vector<TimeZone>& time_zones)
+{
+    auto segments = zone_line.split_view_if([](char ch) { return (ch == '\t') || (ch == ' '); });
+
+    // STDOFF RULES FORMAT [UNTIL]
+    TimeZone time_zone {};
+    time_zone.offset = parse_time(segments[0]);
+
+    if (segments.size() > 3)
+        time_zone.until = parse_date_time(segments.span().slice(3));
+
+    time_zones.append(move(time_zone));
+}
+
+static ErrorOr<void> parse_time_zones(StringView time_zone_path, TimeZoneData& time_zone_data)
+{
+    // For reference, the man page for `zic` has the best documentation of the TZDB file format.
+    auto file = TRY(Core::File::open(time_zone_path, Core::OpenMode::ReadOnly));
+    Vector<TimeZone>* last_parsed_zone = nullptr;
+
+    while (file->can_read_line()) {
+        auto line = file->read_line();
+        if (line.is_empty() || line.trim_whitespace(TrimMode::Left).starts_with('#'))
+            continue;
+
+        if (line.starts_with("Zone"sv)) {
+            last_parsed_zone = &parse_zone(line, time_zone_data);
+        } else if (line.starts_with('\t')) {
+            VERIFY(last_parsed_zone != nullptr);
+            parse_zone_continuation(line, *last_parsed_zone);
+        } else {
+            last_parsed_zone = nullptr;
+        }
+    }
+
+    return {};
+}
+
+static String format_identifier(StringView owner, String identifier)
+{
+    constexpr auto gmt_time_zone = "Etc/GMT"sv;
+
+    if (identifier.starts_with(gmt_time_zone)) {
+        auto offset = identifier.substring_view(gmt_time_zone.length());
+
+        if (offset.starts_with('+'))
+            identifier = String::formatted("{}_P{}", gmt_time_zone, offset.substring_view(1));
+        else if (offset.starts_with('-'))
+            identifier = String::formatted("{}_M{}", gmt_time_zone, offset.substring_view(1));
+    }
+
+    identifier = identifier.replace("-"sv, "_"sv, true);
+    identifier = identifier.replace("/"sv, "_"sv, true);
+
+    if (all_of(identifier, is_ascii_digit))
+        return String::formatted("{}_{}", owner[0], identifier);
+    if (is_ascii_lower_alpha(identifier[0]))
+        return String::formatted("{:c}{}", to_ascii_uppercase(identifier[0]), identifier.substring_view(1));
+    return identifier;
+}
+
+static void generate_time_zone_data_header(Core::File& file, TimeZoneData& time_zone_data)
 {
     StringBuilder builder;
     SourceGenerator generator { builder };
 
     generator.append(R"~~~(
 #pragma once
+
+#include <AK/Types.h>
+
+namespace TimeZone {
+)~~~");
+
+    generate_enum(generator, format_identifier, "TimeZone"sv, {}, time_zone_data.time_zones_names);
+
+    generator.append(R"~~~(
+}
 )~~~");
 
     VERIFY(file.write(generator.as_string_view()));
 }
 
-static void generate_time_zone_data_implementation(Core::File& file)
+static void generate_time_zone_data_implementation(Core::File& file, TimeZoneData& time_zone_data)
 {
     StringBuilder builder;
     SourceGenerator generator { builder };
 
     generator.append(R"~~~(
+#include <AK/Array.h>
+#include <AK/BinarySearch.h>
+#include <AK/Optional.h>
+#include <AK/StringView.h>
+#include <LibTimeZone/TimeZone.h>
 #include <LibTimeZone/TimeZoneData.h>
+
+namespace TimeZone {
+)~~~");
+
+    auto append_from_string = [&](StringView enum_title, StringView enum_snake, auto const& values) {
+        HashValueMap<String> hashes;
+        hashes.ensure_capacity(values.size());
+
+        for (auto const& value : values)
+            hashes.set(value.hash(), format_identifier(enum_title, value));
+
+        generate_value_from_string(generator, "{}_from_string"sv, enum_title, enum_snake, move(hashes));
+    };
+
+    append_from_string("TimeZone"sv, "time_zone"sv, time_zone_data.time_zones_names);
+
+    generator.append(R"~~~(
+}
 )~~~");
 
     VERIFY(file.write(generator.as_string_view()));
@@ -59,8 +254,12 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
     auto generated_header_file = TRY(open_file(generated_header_path));
     auto generated_implementation_file = TRY(open_file(generated_implementation_path));
 
-    generate_time_zone_data_header(generated_header_file);
-    generate_time_zone_data_implementation(generated_implementation_file);
+    TimeZoneData time_zone_data {};
+    for (auto time_zone_path : time_zone_paths)
+        TRY(parse_time_zones(time_zone_path, time_zone_data));
+
+    generate_time_zone_data_header(generated_header_file, time_zone_data);
+    generate_time_zone_data_implementation(generated_implementation_file, time_zone_data);
 
     return 0;
 }

Userland/Libraries/LibTimeZone/CMakeLists.txt

@@ -6,3 +6,15 @@ if (DEFINED TIME_ZONE_DATA_SOURCES)
     target_compile_options(LibTimeZoneData PRIVATE -g0 -Os)
     target_link_libraries(LibTimeZoneData LibCore)
 endif()
+
+set(SOURCES
+    TimeZone.cpp
+)
+
+serenity_lib(LibTimeZone timezone)
+target_link_libraries(LibTimeZone LibCore)
+target_compile_definitions(LibTimeZone PRIVATE ENABLE_TIME_ZONE_DATA=$<BOOL:${ENABLE_TIME_ZONE_DATABASE_DOWNLOAD}>)
+
+if (DEFINED TIME_ZONE_DATA_SOURCES)
+    target_link_libraries(LibTimeZone LibTimeZoneData)
+endif()

Userland/Libraries/LibTimeZone/Forward.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2022, Tim Flynn <trflynn89@pm.me>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Types.h>
+
+namespace TimeZone {
+
+enum class TimeZone : u16;
+
+}

Userland/Libraries/LibTimeZone/TimeZone.cpp

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2022, Tim Flynn <trflynn89@pm.me>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibTimeZone/TimeZone.h>
+
+namespace TimeZone {
+
+Optional<TimeZone> __attribute__((weak)) time_zone_from_string(StringView) { return {}; }
+
+}

Userland/Libraries/LibTimeZone/TimeZone.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2022, Tim Flynn <trflynn89@pm.me>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Optional.h>
+#include <AK/StringView.h>
+#include <LibTimeZone/Forward.h>
+
+namespace TimeZone {
+
+Optional<TimeZone> time_zone_from_string(StringView time_zone);
+
+}