Merge pull request #26 from Billuc/drop-gtempo

Drop gtempo and use gleam_time

Author: Billuc

gleam.toml

@@ -25,7 +25,6 @@ shellout = ">= 1.7.0 and < 2.0.0"
 globlin = ">= 2.0.3 and < 3.0.0"
 globlin_fs = ">= 2.0.0 and < 3.0.0"
 simplifile = ">= 2.2.1 and < 3.0.0"
-gtempo = ">= 7.2.2 and < 8.0.0"
 gleam_crypto = ">= 1.5.1 and < 2.0.0"
 gleam_time = ">= 1.2.0 and < 2.0.0"
 gleam_erlang = ">= 1.2.0 and < 2.0.0"

manifest.toml

@@ -16,7 +16,6 @@ packages = [
   { name = "gleeunit", version = "1.6.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "63022D81C12C17B7F1A60E029964E830A4CBD846BBC6740004FC1F1031AE0326" },
   { name = "globlin", version = "2.0.3", build_tools = ["gleam"], requirements = ["gleam_regexp", "gleam_stdlib"], otp_app = "globlin", source = "hex", outer_checksum = "923BC16814DF95C4BB28111C266F0B873499480E6E125D5A16DBDF732E62CEB4" },
   { name = "globlin_fs", version = "2.0.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib", "globlin", "simplifile"], otp_app = "globlin_fs", source = "hex", outer_checksum = "2A84CE81FD7958B967EF39CC234AFB64DAB20169D0EF9B9C3943CD3C5B561182" },
-  { name = "gtempo", version = "7.2.2", build_tools = ["gleam"], requirements = ["gleam_regexp", "gleam_stdlib", "gleam_time"], otp_app = "gtempo", source = "hex", outer_checksum = "51AACF841C5F936455973BAF7C03F1EEBF86EC0F0F8D9EBEE126CB02968D50AC" },
   { name = "opentelemetry_api", version = "1.4.0", build_tools = ["rebar3", "mix"], requirements = [], otp_app = "opentelemetry_api", source = "hex", outer_checksum = "3DFBBFAA2C2ED3121C5C483162836C4F9027DEF469C41578AF5EF32589FCFC58" },
   { name = "pg_types", version = "0.5.0", build_tools = ["rebar3"], requirements = [], otp_app = "pg_types", source = "hex", outer_checksum = "A3023B464AA960BC1628635081E30CCA4F676F2D4C23CCD6179C1C11C9B4A642" },
   { name = "pgo", version = "0.15.0", build_tools = ["rebar3"], requirements = ["backoff", "opentelemetry_api", "pg_types"], otp_app = "pgo", source = "hex", outer_checksum = "4B883D751B8D4247F4D8A6FBAE58EDB6FA9DBC183371299BF84975EE36406388" },
@@ -36,7 +35,6 @@ gleam_time = { version = ">= 1.2.0 and < 2.0.0" }
 gleeunit = { version = ">= 1.6.0 and < 2.0.0" }
 globlin = { version = ">= 2.0.3 and < 3.0.0" }
 globlin_fs = { version = ">= 2.0.0 and < 3.0.0" }
-gtempo = { version = ">= 7.2.2 and < 8.0.0" }
 pog = { version = ">= 4.0.0 and < 5.0.0" }
 shellout = { version = ">= 1.7.0 and < 2.0.0" }
 simplifile = { version = ">= 2.2.1 and < 3.0.0" }

src/cigogne.gleam

@@ -8,8 +8,7 @@ import gleam/int
 import gleam/io
 import gleam/list
 import gleam/result
-import tempo/datetime
-import tempo/instant
+import gleam/time/timestamp
 
 type SchemaData {
   SchemaData(generate: Bool, filename: String)
@@ -137,9 +136,7 @@ pub fn new_migration(
 ) -> Result(Nil, types.MigrateError) {
   use path <- result.map(fs.create_new_migration_file(
     migrations_folder,
-    instant.now()
-      |> instant.as_utc_datetime()
-      |> datetime.drop_offset(),
+    timestamp.system_time(),
     name,
   ))
   io.println("Migration file created : " <> path)

src/cigogne/internal/database.gleam

@@ -191,9 +191,7 @@ fn insert_migration_query(
 ) -> pog.Query(Nil) {
   query_insert_migration(data.schema, data.migrations_table_name)
   |> pog.query()
-  |> pog.parameter(pog.timestamp(
-    migration.timestamp |> utils.tempo_to_pog_timestamp,
-  ))
+  |> pog.parameter(pog.timestamp(migration.timestamp))
   |> pog.parameter(pog.text(migration.name))
   |> pog.parameter(pog.text(migration.sha256))
 }
@@ -205,9 +203,7 @@ fn drop_migration_query(
   query_drop_migration(data.schema, data.migrations_table_name)
   |> pog.query()
   |> pog.parameter(pog.text(migration.name))
-  |> pog.parameter(pog.timestamp(
-    migration.timestamp |> utils.tempo_to_pog_timestamp,
-  ))
+  |> pog.parameter(pog.timestamp(migration.timestamp))
 }
 
 pub fn get_applied_migrations(
@@ -226,19 +222,15 @@ pub fn get_applied_migrations(
   |> result.try(fn(returned) {
     case returned.rows {
       [] -> Error(types.NoResultError)
-      _ as applied -> applied |> list.try_map(build_migration_data)
+      _ as applied -> applied |> list.map(build_migration_data) |> Ok
     }
   })
 }
 
 fn build_migration_data(
   data: #(timestamp.Timestamp, String, String),
-) -> Result(types.Migration, types.MigrateError) {
-  case utils.pog_to_tempo_timestamp(data.0) {
-    Error(_) ->
-      Error(types.DateParseError(utils.pog_timestamp_to_string(data.0)))
-    Ok(timestamp) -> Ok(types.Migration("", timestamp, data.1, [], [], data.2))
-  }
+) -> types.Migration {
+  types.Migration("", data.0, data.1, [], [], data.2)
 }
 
 pub fn get_schema(data: DatabaseData) -> Result(String, types.MigrateError) {

src/cigogne/internal/fs.gleam

@@ -4,10 +4,10 @@ import cigogne/internal/utils
 import cigogne/types
 import gleam/list
 import gleam/result
+import gleam/time/timestamp
 import globlin
 import globlin_fs
 import simplifile
-import tempo
 
 pub fn get_migrations(
   migrations_folder: String,
@@ -78,7 +78,7 @@ pub fn write_schema_file(
 
 pub fn create_new_migration_file(
   migrations_folder: String,
-  timestamp: tempo.NaiveDateTime,
+  timestamp: timestamp.Timestamp,
   name: String,
 ) -> Result(String, types.MigrateError) {
   use name <- result.try(migrations_utils.check_name(name))

src/cigogne/internal/migration_parser.gleam

@@ -5,8 +5,7 @@ import gleam/list
 import gleam/option
 import gleam/result
 import gleam/string
-import tempo
-import tempo/naive_datetime
+import gleam/time/timestamp
 
 pub const migration_up_guard = "--- migration:up"
 
@@ -16,7 +15,7 @@ pub const migration_end_guard = "--- migration:end"
 
 pub fn parse_file_name(
   path: String,
-) -> Result(#(tempo.NaiveDateTime, String), types.MigrateError) {
+) -> Result(#(timestamp.Timestamp, String), types.MigrateError) {
   use <- bool.guard(
     !string.ends_with(path, ".sql"),
     Error(types.FileNameError(path)),
@@ -30,10 +29,7 @@ pub fn parse_file_name(
     |> result.replace_error(types.FileNameError(path)),
   )
 
-  use ts <- result.try(
-    naive_datetime.parse(ts_and_name.0, migrations_utils.timestamp_format)
-    |> result.replace_error(types.DateParseError(ts_and_name.0)),
-  )
+  use ts <- result.try(migrations_utils.parse_migration_timestamp(ts_and_name.0))
   use name <- result.try(migrations_utils.check_name(ts_and_name.1))
 
   #(ts, name) |> Ok

src/cigogne/internal/migrations_utils.gleam

@@ -1,30 +1,79 @@
 import cigogne/internal/utils
 import cigogne/types
 import gleam/bool
+import gleam/int
 import gleam/list
 import gleam/option
 import gleam/order
 import gleam/result
 import gleam/string
-import tempo
-import tempo/naive_datetime
-
-pub const timestamp_format = tempo.CustomNaive("YYYYMMDDHHmmss")
+import gleam/time/calendar
+import gleam/time/timestamp
 
 const max_name_length = 255
 
+pub fn format_migration_timestamp(timestamp: timestamp.Timestamp) -> String {
+  let #(date, time) = timestamp |> timestamp.to_calendar(calendar.utc_offset)
+
+  let date_str =
+    [date.year, date.month |> calendar.month_to_int, date.day]
+    |> list.map(int_to_2_chars_string)
+    |> string.join("")
+  let time_str =
+    [time.hours, time.minutes, time.seconds]
+    |> list.map(int_to_2_chars_string)
+    |> string.join("")
+
+  date_str <> time_str
+}
+
+fn int_to_2_chars_string(n: Int) -> String {
+  case n {
+    n if n < 10 -> "0" <> int.to_string(n)
+    _ -> int.to_string(n)
+  }
+}
+
+pub fn parse_migration_timestamp(
+  timestamp_str: String,
+) -> Result(timestamp.Timestamp, types.MigrateError) {
+  use <- bool.guard(
+    string.length(timestamp_str) != 14,
+    Error(types.DateParseError(timestamp_str)),
+  )
+
+  let year = string.slice(timestamp_str, 0, 4) |> int.parse
+  let month = string.slice(timestamp_str, 4, 2) |> int.parse
+  let day = string.slice(timestamp_str, 6, 2) |> int.parse
+  let hours = string.slice(timestamp_str, 8, 2) |> int.parse
+  let minutes = string.slice(timestamp_str, 10, 2) |> int.parse
+  let seconds = string.slice(timestamp_str, 12, 2) |> int.parse
+
+  case year, month, day, hours, minutes, seconds {
+    Ok(y), Ok(m), Ok(d), Ok(h), Ok(min), Ok(s) -> {
+      calendar.month_from_int(m)
+      |> result.replace_error(types.DateParseError(timestamp_str))
+      |> result.map(fn(m) {
+        timestamp.from_calendar(
+          calendar.Date(y, m, d),
+          calendar.TimeOfDay(h, min, s, 0),
+          calendar.utc_offset,
+        )
+      })
+    }
+    _, _, _, _, _, _ -> Error(types.DateParseError(timestamp_str))
+  }
+}
+
 pub fn format_migration_name(migration: types.Migration) -> String {
-  migration.timestamp
-  |> naive_datetime.format(timestamp_format)
-  <> "-"
-  <> migration.name
+  format_migration_timestamp(migration.timestamp) <> "-" <> migration.name
 }
 
 pub fn to_migration_filename(
-  timestamp: tempo.NaiveDateTime,
+  timestamp: timestamp.Timestamp,
   name: String,
 ) -> String {
-  timestamp |> naive_datetime.format(timestamp_format) <> "-" <> name <> ".sql"
+  format_migration_timestamp(timestamp) <> "-" <> name <> ".sql"
 }
 
 pub fn check_name(name: String) -> Result(String, types.MigrateError) {
@@ -40,9 +89,7 @@ pub fn find_migration(
   data: types.Migration,
 ) -> Result(types.Migration, types.MigrateError) {
   migrations
-  |> list.find(fn(m) {
-    naive_datetime.is_equal(m.timestamp, data.timestamp) && m.name == data.name
-  })
+  |> list.find(fn(m) { m.timestamp == data.timestamp && m.name == data.name })
   |> result.replace_error(types.MigrationNotFoundError(
     data.timestamp,
     data.name,
@@ -53,7 +100,7 @@ pub fn compare_migrations(
   migration_a: types.Migration,
   migration_b: types.Migration,
 ) -> order.Order {
-  naive_datetime.compare(migration_a.timestamp, migration_b.timestamp)
+  timestamp.compare(migration_a.timestamp, migration_b.timestamp)
   |> order.break_tie(string.compare(migration_a.name, migration_b.name))
 }
 
@@ -204,7 +251,7 @@ pub fn create_zero_migration(
 ) -> types.Migration {
   types.Migration(
     "",
-    utils.tempo_epoch(),
+    utils.epoch(),
     name,
     queries_up,
     queries_down,
@@ -216,6 +263,5 @@ pub fn create_zero_migration(
 
 /// Checks if a migration is a zero migration (has been created with create_zero_migration)
 pub fn is_zero_migration(migration: types.Migration) -> Bool {
-  { migration.path == "" }
-  |> bool.and(naive_datetime.is_equal(migration.timestamp, utils.tempo_epoch()))
+  migration.path == "" && migration.timestamp == utils.epoch()
 }

src/cigogne/internal/utils.gleam

@@ -3,15 +3,10 @@ import gleam/crypto
 import gleam/dynamic/decode
 import gleam/int
 import gleam/list
-import gleam/result
 import gleam/string
 import gleam/time/calendar
 import gleam/time/timestamp
 import pog
-import tempo
-import tempo/date
-import tempo/naive_datetime
-import tempo/time
 
 pub fn describe_query_error(error: pog.QueryError) -> String {
   case error {
@@ -52,56 +47,10 @@ pub fn describe_decode_error(error: decode.DecodeError) -> String {
   <> "]"
 }
 
-pub fn tempo_to_pog_timestamp(from: tempo.NaiveDateTime) -> timestamp.Timestamp {
-  let #(#(year, month, day), #(hour, minutes, seconds)) =
-    from |> naive_datetime.to_tuple
-
-  let assert Ok(month) = calendar.month_from_int(month)
-
-  let date = calendar.Date(year, month, day)
-  let time = calendar.TimeOfDay(hour, minutes, seconds, 0)
-
-  timestamp.from_calendar(date, time, calendar.utc_offset)
-}
-
-pub fn pog_to_tempo_timestamp(
-  from: timestamp.Timestamp,
-) -> Result(tempo.NaiveDateTime, Nil) {
-  let #(date, time_of_day) = from |> timestamp.to_calendar(calendar.utc_offset)
-
-  use date <- result.try(pog_to_tempo_date(date))
-  use time <- result.try(pog_to_tempo_time(time_of_day))
-  Ok(naive_datetime.new(date, time))
-}
-
-fn pog_to_tempo_date(from: calendar.Date) -> Result(tempo.Date, Nil) {
-  date.new(from.year, from.month |> calendar.month_to_int(), from.day)
-  |> result.replace_error(Nil)
-}
-
-fn pog_to_tempo_time(from: calendar.TimeOfDay) -> Result(tempo.Time, Nil) {
-  time.new(from.hours, from.minutes, from.seconds) |> result.replace_error(Nil)
-}
-
-pub fn pog_timestamp_to_string(value: timestamp.Timestamp) -> String {
-  let #(date, time_of_day) = value |> timestamp.to_calendar(calendar.utc_offset)
-
-  [date.year, date.month |> calendar.month_to_int(), date.day]
-  |> list.map(int.to_string)
-  |> string.join("-")
-  <> " "
-  <> [time_of_day.hours, time_of_day.minutes, time_of_day.seconds]
-  |> list.map(fn(v: Int) {
-    case v {
-      v if v < 10 -> "0" <> int.to_string(v)
-      _ -> int.to_string(v)
-    }
-  })
-  |> string.join(":")
-}
-
-pub fn tempo_epoch() -> tempo.NaiveDateTime {
-  naive_datetime.literal("1970-01-01 00:00:00")
+pub fn epoch() -> timestamp.Timestamp {
+  let epoch_date = calendar.Date(1970, calendar.January, 1)
+  let epoch_time = calendar.TimeOfDay(0, 0, 0, 0)
+  timestamp.from_calendar(epoch_date, epoch_time, calendar.utc_offset)
 }
 
 pub fn make_sha256(content: String) -> String {

src/cigogne/to_v3.gleam

@@ -1,7 +1,6 @@
 import cigogne/internal/database
 import cigogne/internal/fs
 import cigogne/internal/migrations_utils
-import cigogne/internal/utils
 import cigogne/types
 import gleam/bool
 import gleam/dynamic/decode
@@ -87,9 +86,7 @@ fn set_hash(
     |> pog.query()
     |> pog.parameter(pog.text(file.sha256))
     |> pog.parameter(pog.text(file.name))
-    |> pog.parameter(pog.timestamp(
-      file.timestamp |> utils.tempo_to_pog_timestamp,
-    ))
+    |> pog.parameter(pog.timestamp(file.timestamp))
     |> pog.execute(connection)
     |> result.map_error(types.PGOQueryError)
     |> result.map(fn(_) {