middle of moving things tests not updated

Author: devries

examples/time_now/src/time_now.gleam

@@ -1,10 +1,11 @@
 import gleam/int
 import gleam/io
-import gleam/result
+import gleam/list
 import gleam/string
 import gleam/time/calendar
 import gleam/time/timestamp
 import timezone
+import timezone/database
 
 pub fn main() {
   let now = timestamp.system_time()
@@ -17,44 +18,19 @@ pub fn main() {
 fn print_all_times(
   now: timestamp.Timestamp,
 ) -> Result(Nil, timezone.TimeZoneError) {
-  use new_york <- result.try(timezone.get_time_in_zone(now, "America/New_York"))
-  use vevay <- result.try(timezone.get_time_in_zone(
-    now,
-    "America/Indiana/Vevay",
-  ))
-  use utc <- result.try(timezone.get_time_in_zone(now, "UTC"))
-  use phoenix <- result.try(timezone.get_time_in_zone(now, "America/Phoenix"))
-  use amsterdam <- result.try(timezone.get_time_in_zone(now, "Europe/Amsterdam"))
-  use london <- result.try(timezone.get_time_in_zone(now, "Europe/London"))
-  use tokyo <- result.try(timezone.get_time_in_zone(now, "Asia/Tokyo"))
-  use auckland <- result.try(timezone.get_time_in_zone(now, "Pacific/Auckland"))
-  use cairo <- result.try(timezone.get_time_in_zone(now, "Africa/Cairo"))
-  use calcutta <- result.try(timezone.get_time_in_zone(now, "Asia/Calcutta"))
-  use posix <- result.try(timezone.get_time_in_zone(now, "posixrules"))
+  let db = database.load_from_os()
 
-  io.println("UTC:       " <> format_time(utc))
-  io.println("New York:  " <> format_time(new_york))
-  io.println("Vevay:     " <> format_time(vevay))
-  io.println("Phoenix:   " <> format_time(phoenix))
-  io.println("Amsterdam: " <> format_time(amsterdam))
-  io.println("London:    " <> format_time(london))
-  io.println("Tokyo:     " <> format_time(tokyo))
-  io.println("Auckland:  " <> format_time(auckland))
-  io.println("Cairo:     " <> format_time(cairo))
-  io.println("Calcutta:  " <> format_time(calcutta))
-  io.println("POSIX:     " <> format_time(posix))
-  io.println("")
-  io.println("RFC3339:")
-  io.println("UTC:       " <> timestamp.to_rfc3339(now, utc.offset))
-  io.println("New York:  " <> timestamp.to_rfc3339(now, new_york.offset))
-  io.println("Vevay:     " <> timestamp.to_rfc3339(now, vevay.offset))
-  io.println("Phoenix:   " <> timestamp.to_rfc3339(now, phoenix.offset))
-  io.println("Amsterdam: " <> timestamp.to_rfc3339(now, amsterdam.offset))
-  io.println("London:    " <> timestamp.to_rfc3339(now, london.offset))
-  io.println("Tokyo:     " <> timestamp.to_rfc3339(now, tokyo.offset))
-  io.println("Auckland:  " <> timestamp.to_rfc3339(now, auckland.offset))
-  io.println("Cairo:     " <> timestamp.to_rfc3339(now, cairo.offset))
-  io.println("POSIX:     " <> timestamp.to_rfc3339(now, posix.offset))
+  database.get_available_timezones(db)
+  |> list.map(fn(zone_name) {
+    case timezone.get_time_in_zone_tzdb(now, zone_name, db) {
+      Ok(tiz) ->
+        io.println(
+          string.pad_end(zone_name <> ":", 40, " ") <> format_time(tiz),
+        )
+      Error(_) ->
+        io.println(string.pad_end(zone_name <> ":", 40, " ") <> "ERROR")
+    }
+  })
   Ok(Nil)
 }
 

src/timezone.gleam

@@ -16,94 +16,36 @@
 //// article on Wikipedia. The time zone identifiers are passed to many of the
 //// functions of this library as the `zone_name` parameter.
 
-import envoy
-import filepath
-import gleam/dict
-import gleam/list
 import gleam/result
 import gleam/time/calendar.{type Date, type TimeOfDay}
 import gleam/time/duration.{type Duration}
 import gleam/time/timestamp.{type Timestamp}
-import simplifile
 import timezone/database
-import timezone/internal
 
 /// Time Zone error type
+/// This needs review and change as we split things up
 pub type TimeZoneError {
+  /// Error parsing timezone data
   ParseError
+
+  /// Error constructing time zone transition table.
   TimeSliceError
-  ZoneFileError
-}
 
-/// Timezone definition slice
-type TTSlice {
-  TTSlice(start_time: Int, utoff: Duration, isdst: Bool, designation: String)
+  /// Other error in the Zone file
+  ZoneFileError
 }
 
 /// Representation of time in a time zone
 pub type TimeInZone {
   TimeInZone(
     date: Date,
     time_of_day: TimeOfDay,
-    offset: duration.Duration,
+    offset: Duration,
     designation: String,
     is_dst: Bool,
   )
 }
 
-/// Get the full path to the zoneinfo file for that
-/// time zone. Use IANA time zone identifiers such as
-/// "America/New_York".
-pub fn tzfile_path(name: String) -> String {
-  let root = case envoy.get("ZONEINFO") {
-    Ok(dir) -> dir
-    _ -> "/usr/share/zoneinfo"
-  }
-
-  filepath.join(root, name)
-}
-
-/// Given a timestamp and a zone name, get the time in that time zone.
-/// The zone_name should be an IANA identifier like "America/New_York".
-pub fn get_time_in_zone(
-  ts: Timestamp,
-  zone_name: String,
-) -> Result(TimeInZone, TimeZoneError) {
-  // Parse the datafile
-  use tzdata <- result.try(
-    tzfile_path(zone_name)
-    |> simplifile.read_bits
-    |> result.replace_error(ZoneFileError),
-  )
-  get_time_with_tzdata(ts, tzdata)
-}
-
-/// Given a timestamp and the binary contents of a tzfile, get the time in
-/// that time zone.
-pub fn get_time_with_tzdata(
-  ts: Timestamp,
-  tzdata: BitArray,
-) -> Result(TimeInZone, TimeZoneError) {
-  use tz <- result.try(
-    internal.parse(tzdata) |> result.replace_error(ParseError),
-  )
-
-  // Pull out the TTSlice representing the timezone at that timestamp
-  use slice_of_interest <- result.map(
-    get_slice(ts, create_slices(tz.fields), default_slice(tz.fields))
-    |> result.replace_error(TimeSliceError),
-  )
-  let #(dt, tm) = timestamp.to_calendar(ts, slice_of_interest.utoff)
-
-  TimeInZone(
-    dt,
-    tm,
-    slice_of_interest.utoff,
-    slice_of_interest.designation,
-    slice_of_interest.isdst,
-  )
-}
-
 /// Potentially new API for time_in_zone
 pub fn get_time_in_zone_tzdb(
   ts: Timestamp,
@@ -125,85 +67,3 @@ pub fn get_time_in_zone_tzdb(
     zone_parameters.is_dst,
   )
 }
-
-/// Convert a timestamp to a calendar date and time of day for a
-/// given time zone.
-pub fn to_calendar(
-  ts: Timestamp,
-  zone_name: String,
-) -> Result(#(calendar.Date, calendar.TimeOfDay), TimeZoneError) {
-  use time_in_zone <- result.map(get_time_in_zone(ts, zone_name))
-
-  #(time_in_zone.date, time_in_zone.time_of_day)
-}
-
-/// Get the offset for a time zone at a particular moment in time.
-pub fn zone_offset(
-  ts: Timestamp,
-  zone_name: String,
-) -> Result(duration.Duration, TimeZoneError) {
-  use time_in_zone <- result.map(get_time_in_zone(ts, zone_name))
-
-  time_in_zone.offset
-}
-
-/// Get zone designation (e.g. "EST", "CEST", "JST").
-pub fn zone_designation(
-  ts: Timestamp,
-  zone_name: String,
-) -> Result(String, TimeZoneError) {
-  use time_in_zone <- result.map(get_time_in_zone(ts, zone_name))
-
-  time_in_zone.designation
-}
-
-// Turn time zone fields into a list of timezone information slices
-fn create_slices(fields: internal.TimeZoneFields) -> List(TTSlice) {
-  let infos =
-    list.zip(fields.ttinfos, fields.designations)
-    |> list.index_map(fn(tup, idx) { #(idx, tup) })
-    |> dict.from_list
-
-  list.zip(fields.transition_times, fields.time_types)
-  |> list.map(fn(tup) {
-    let info_tuple = dict.get(infos, tup.1)
-    case info_tuple {
-      Ok(#(ttinfo, designation)) -> {
-        let isdst = case ttinfo.isdst {
-          0 -> False
-          _ -> True
-        }
-        Ok(TTSlice(tup.0, duration.seconds(ttinfo.utoff), isdst, designation))
-      }
-      _ -> Error(Nil)
-    }
-  })
-  |> result.values
-}
-
-fn default_slice(fields: internal.TimeZoneFields) -> Result(TTSlice, Nil) {
-  use ttinfo <- result.try(list.first(fields.ttinfos))
-  use designation <- result.try(list.first(fields.designations))
-  let isdst = case ttinfo.isdst {
-    0 -> False
-    _ -> True
-  }
-
-  Ok(TTSlice(0, duration.seconds(ttinfo.utoff), isdst, designation))
-}
-
-fn get_slice(
-  ts: timestamp.Timestamp,
-  slices: List(TTSlice),
-  default: Result(TTSlice, Nil),
-) -> Result(TTSlice, Nil) {
-  let #(seconds, _) = timestamp.to_unix_seconds_and_nanoseconds(ts)
-
-  slices
-  |> list.fold_until(default, fn(acc, slice) {
-    case slice.start_time < seconds {
-      True -> list.Continue(Ok(slice))
-      False -> list.Stop(acc)
-    }
-  })
-}

src/timezone/database.gleam

@@ -6,19 +6,21 @@ import gleam/string
 import gleam/time/duration.{type Duration}
 import gleam/time/timestamp
 import simplifile
-import timezone/internal
+import timezone/tzparser
 
 pub opaque type TzDatabase {
   TzDatabase(
     zone_names: List(String),
-    zone_data: dict.Dict(String, internal.TimeZoneData),
+    zone_data: dict.Dict(String, tzparser.TZFile),
   )
 }
 
+/// Load timezone database from default operating system location
 pub fn load_from_os() {
   load_from_path("/usr/share/zoneinfo")
 }
 
+/// Load timezone database from provided directory
 pub fn load_from_path(path: String) {
   let parts = filepath.split(path)
   let drop_number = list.length(parts)
@@ -38,7 +40,7 @@ pub fn load_from_path(path: String) {
 fn process_tzfile(
   filename: String,
   components_to_drop: Int,
-) -> Result(#(String, internal.TimeZoneData), Nil) {
+) -> Result(#(String, tzparser.TZFile), Nil) {
   let zone_name =
     filepath.split(filename)
     |> list.drop(components_to_drop)
@@ -49,16 +51,21 @@ fn process_tzfile(
   )
 
   use timeinfo <- result.try(
-    internal.parse(tzdata) |> result.replace_error(Nil),
+    tzparser.parse(tzdata) |> result.replace_error(Nil),
   )
 
   Ok(#(zone_name, timeinfo))
 }
 
+/// Get all timezones in the database
 pub fn get_available_timezones(db: TzDatabase) -> List(String) {
   db.zone_names
 }
 
+/// Time zone parameters record.
+/// - `offset` is the offset from UTC.
+/// - `is_dst` indicates if it is daylight savings time
+/// - `designation` is the time zone designation
 pub type ZoneParameters {
   ZoneParameters(offset: Duration, is_dst: Bool, designation: String)
 }
@@ -86,7 +93,7 @@ type TTSlice {
 }
 
 // Turn time zone fields into a list of timezone information slices
-fn create_slices(fields: internal.TimeZoneFields) -> List(TTSlice) {
+fn create_slices(fields: tzparser.TZFileFields) -> List(TTSlice) {
   let infos =
     list.zip(fields.ttinfos, fields.designations)
     |> list.index_map(fn(tup, idx) { #(idx, tup) })
@@ -109,7 +116,7 @@ fn create_slices(fields: internal.TimeZoneFields) -> List(TTSlice) {
   |> result.values
 }
 
-fn default_slice(fields: internal.TimeZoneFields) -> Result(TTSlice, Nil) {
+fn default_slice(fields: tzparser.TZFileFields) -> Result(TTSlice, Nil) {
   use ttinfo <- result.try(list.first(fields.ttinfos))
   use designation <- result.try(list.first(fields.designations))
   let isdst = case ttinfo.isdst {