feat: Relax UnixTime construction from String

Author: Beforerr

src/UnixTimes.jl

@@ -12,16 +12,17 @@ struct UnixTime <: Dates.AbstractDateTime
 end
 
 function UnixTime(
-    y::Integer,
-    m::Integer = 1,
-    d::Integer = 1,
-    h::Integer = 0,
-    mi::Integer = 0,
-    s::Integer = 0,
-    ms::Integer = 0,
-    us::Integer = 0,
-    ns::Integer = 0)
-    convert(UnixTime, DateTime(y, m, d, h, mi, s, ms)) + Nanosecond(us * 1000 + ns)
+        y::Integer,
+        m::Integer = 1,
+        d::Integer = 1,
+        h::Integer = 0,
+        mi::Integer = 0,
+        s::Integer = 0,
+        ms::Integer = 0,
+        us::Integer = 0,
+        ns::Integer = 0
+    )
+    return convert(UnixTime, DateTime(y, m, d, h, mi, s, ms)) + Nanosecond(us * 1000 + ns)
 end
 
 const UNIX_EPOCH = UnixTime(Dates.UTInstant(Nanosecond(0)))
@@ -41,12 +42,12 @@ Base.:-(x::UnixTime, p::Period) = x + (-p)
 
 function Base.:+(x::UnixTime, p::Union{Month, Year})
     trunc_ns = mod(Dates.value(x), 1_000_000)
-    convert(UnixTime, convert(DateTime, x) + p) + Nanosecond(trunc_ns)
+    return convert(UnixTime, convert(DateTime, x) + p) + Nanosecond(trunc_ns)
 end
 
 function Dates.DateTime(x::UnixTime)
     instant_ms = Dates.UNIXEPOCH + div(x.instant.periods.value, 1_000_000)
-    DateTime(Dates.UTM(instant_ms))
+    return DateTime(Dates.UTM(instant_ms))
 end
 
 Dates.Date(x::UnixTime) = Date(DateTime(x))
@@ -63,19 +64,39 @@ UnixTime(x::Date, y::Time) =
 const DATEFORMAT = dateformat"yyyy-mm-ddTHH:MM:SS.sss"
 
 function UnixTime(s::AbstractString)
-    try
-        @assert length(s) == 29
-        dt = DateTime(chop(s; tail=6), DATEFORMAT)
-        ns = Nanosecond(parse(Int, last(s, 6)))
-        UnixTime(dt) + ns
-    catch
-        throw(ArgumentError("Invalid UnixTime string"))
+    # Find the decimal point if it exists
+    dot_idx = findfirst('.', s)
+
+    # No fractional seconds, parse as DateTime
+    isnothing(dot_idx) && return UnixTime(DateTime(s))
+
+    # Split into datetime and fractional parts
+    dt_part = @view s[1:(dot_idx - 1)]
+    frac_part = @view s[(dot_idx + 1):end]
+
+    # Parse the datetime part
+    dt = DateTime(dt_part)
+
+    # Parse fractional seconds (can be 1-9 digits)
+    if isempty(frac_part) || !all(isdigit, frac_part)
+        throw(ArgumentError("Invalid fractional seconds in UnixTime string"))
     end
+
+    # Convert fractional seconds to nanoseconds
+    # Pad or truncate to 9 digits (nanosecond precision)
+    frac_digits = length(frac_part)
+    ns_value = if frac_digits <= 9
+        parse(Int, frac_part) * 10^(9 - frac_digits)
+    else
+        parse(Int, frac_part[1:9])
+    end
+
+    return UnixTime(dt) + Nanosecond(ns_value)
 end
 
 function Base.convert(::Type{UnixTime}, x::DateTime)
     instant_ns = (Dates.value(x) - Dates.UNIXEPOCH) * 1_000_000
-    UnixTime(Dates.UTInstant(Nanosecond(instant_ns)))
+    return UnixTime(Dates.UTInstant(Nanosecond(instant_ns)))
 end
 
 # Promotion rules for comparing UnixTime with DateTime
@@ -90,11 +111,11 @@ function Base.show(io::IO, x::UnixTime)
         print(io, div(v, d) % 10 + '0')
         d = div(d, 10)
     end
-    nothing
+    return nothing
 end
 
 function Base.floor(x::UnixTime, p::Union{DatePeriod, TimePeriod})
-    convert(UnixTime, floor(convert(DateTime, x), p))
+    return convert(UnixTime, floor(convert(DateTime, x), p))
 end
 
 Dates.guess(a::UnixTime, b::UnixTime, c) = (Dates.value(b) - Dates.value(a)) ÷ Dates.tons(c)
@@ -111,12 +132,12 @@ if Sys.islinux()
         ts = Ref{LinuxTimespec}()
         ccall(:clock_gettime, Cint, (Cint, Ref{LinuxTimespec}), 0, ts)
         x = ts[]
-        UnixTime(Dates.UTInstant(Nanosecond(x.seconds * 1_000_000_000 + x.nanoseconds)))
+        return UnixTime(Dates.UTInstant(Nanosecond(x.seconds * 1_000_000_000 + x.nanoseconds)))
     end
 else
     @inline function unix_now()
         tv = Libc.TimeVal()
-        UnixTime(Dates.UTInstant(Nanosecond(tv.sec * 1_000_000_000 + tv.usec * 1_000)))
+        return UnixTime(Dates.UTInstant(Nanosecond(tv.sec * 1_000_000_000 + tv.usec * 1_000)))
     end
 end
 

test/runtests.jl

@@ -48,9 +48,22 @@ end
     x = UnixTime(2020, 1, 2, 3, 4, 5, 6, 7, 8)
     @test string(x) == "2020-01-02T03:04:05.006007008"
     @test UnixTime(string(x)) == x
-    @test_throws ArgumentError UnixTime("2025-01-28T15:49:36.5901397023")
-    @test_throws ArgumentError UnixTime("2025-01-28T15:49:36.59013970")
-    @test_throws ArgumentError UnixTime(repeat("a", 29))
+
+    # Test various string formats
+    @test UnixTime("2020-01-02T03:04:05") == UnixTime(2020, 1, 2, 3, 4, 5)
+    @test UnixTime("2020-01-02T03:04:05.1") == UnixTime(2020, 1, 2, 3, 4, 5, 100)
+    @test UnixTime("2020-01-02T03:04:05.12") == UnixTime(2020, 1, 2, 3, 4, 5, 120)
+    @test UnixTime("2020-01-02T03:04:05.123") == UnixTime(2020, 1, 2, 3, 4, 5, 123)
+    @test UnixTime("2020-01-02T03:04:05.1234") == UnixTime(2020, 1, 2, 3, 4, 5, 123, 400)
+    @test UnixTime("2020-01-02T03:04:05.123456") == UnixTime(2020, 1, 2, 3, 4, 5, 123, 456)
+    @test UnixTime("2020-01-02T03:04:05.123456789") == UnixTime(2020, 1, 2, 3, 4, 5, 123, 456, 789)
+
+    # Test truncation of extra digits
+    @test UnixTime("2020-01-02T03:04:05.1234567890") == UnixTime(2020, 1, 2, 3, 4, 5, 123, 456, 789)
+
+    # Test invalid formats
+    @test_throws ArgumentError UnixTime("2020-01-02T03:04:05.")
+    @test_throws ArgumentError UnixTime("2020-01-02T03:04:05.abc")
 end
 
 @testset "arithmetic" begin