defmodule Timex.Parse.DateTime.Parsers.ISO8601Extended do
use Combine.Helpers
alias Combine.ParserState
defparser parse(%ParserState{status: :ok, column: col, input: input, results: results} = state) do
case parse_extended(input) do
{:ok, parts, len, remaining} ->
%{
state
| :column => col + len,
:input => remaining,
:results => [Enum.reverse(parts) | results]
}
{:error, reason, count} ->
%{state | :status => :error, :column => col + count, :error => reason}
end
end
def parse_extended(<<>>), do: {:error, "Expected year, but got end of input."}
def parse_extended(input), do: parse_extended(input, :year, [], 0)
def parse_extended(
<<y1::utf8, y2::utf8, y3::utf8, y4::utf8, "-", rest::binary>>,
:year,
acc,
count
)
when y1 >= ?0 and y1 <= ?9 and
y2 >= ?0 and y2 <= ?9 and
y3 >= ?0 and y3 <= ?9 and
y4 >= ?0 and y4 <= ?9 do
year = String.to_integer(<<y1::utf8, y2::utf8, y3::utf8, y4::utf8>>)
parse_extended(rest, :month, [{:year4, year} | acc], count + 4)
end
def parse_extended(<<h::utf8, _::binary>>, :year, _acc, count),
do: {:error, "Expected 4 digit year, but got `#{<<h::utf8>>}` instead.", count}
def parse_extended(_, :year, _acc, count),
do: {:error, "Expected 4 digit year.", count}
def parse_extended(<<m1::utf8, m2::utf8, "-", rest::binary>>, :month, acc, count)
when m1 >= ?0 and m1 < ?2 and
m2 >= ?0 and m2 <= ?9 do
month = String.to_integer(<<m1::utf8, m2::utf8>>)
cond do
month > 0 and month < 13 ->
parse_extended(rest, :day, [{:month, month} | acc], count + 2)
:else ->
{:error, "Expected month between 1-12, but got `#{month}` instead.", count}
end
end
def parse_extended(<<h::utf8, _::binary>>, :month, _acc, count),
do: {:error, "Expected 2 digit month, but got `#{<<h::utf8>>}` instead.", count}
def parse_extended(_, :month, _acc, count),
do: {:error, "Expected 2 digit month.", count}
def parse_extended(<<d1::utf8, d2::utf8, sep::utf8, rest::binary>>, :day, acc, count)
when d1 >= ?0 and d1 <= ?3 and
d2 >= ?0 and d2 <= ?9 do
cond do
sep in [?T, ?\s] ->
day = String.to_integer(<<d1::utf8, d2::utf8>>)
cond do
day > 0 and day < 32 ->
parse_extended(rest, :hour, [{:day, day} | acc], count + 3)
:else ->
{:error, "Expected day between 1-31, but got `#{day}` instead.", count}
end
:else ->
{:error,
"Expected valid date/time separator (T or space), but got `#{<<sep::utf8>>}` instead.",
count + 2}
end
end
def parse_extended(<<h::utf8, _::binary>>, :day, _acc, count),
do: {:error, "Expected 2 digit day, but got `#{<<h::utf8>>}` instead.", count}
def parse_extended(_, :day, _acc, count),
do: {:error, "Expected 2 digit day.", count}
def parse_extended(<<h1::utf8, h2::utf8, rest::binary>>, :hour, acc, count)
when h1 >= ?0 and h1 < ?3 and
h2 >= ?0 and h2 <= ?9 do
hour = String.to_integer(<<h1::utf8, h2::utf8>>)
cond do
hour >= 0 and hour <= 24 ->
case rest do
<<":", rest::binary>> ->
parse_extended(rest, :minute, [{:hour24, hour} | acc], count + 3)
_ ->
parse_offset(rest, [{:hour24, hour} | acc], count + 2)
end
:else ->
{:error, "Expected hour between 0-24, but got `#{hour}` instead.", count}
end
end
def parse_extended(<<h::utf8, _::binary>>, :hour, _acc, count),
do: {:error, "Expected 2 digit hour, but got `#{<<h::utf8>>}` instead.", count}
def parse_extended(_, :hour, _acc, count),
do: {:error, "Expected 2 digit hour.", count}
# Minutes are optional
def parse_extended(<<m1::utf8, m2::utf8, rest::binary>>, :minute, acc, count)
when m1 >= ?0 and m1 < ?6 and
m2 >= ?0 and m2 <= ?9 do
minute = String.to_integer(<<m1::utf8, m2::utf8>>)
cond do
minute >= 0 and minute <= 60 ->
case rest do
<<":", rest::binary>> ->
parse_extended(rest, :second, [{:min, minute} | acc], count + 3)
_ ->
parse_offset(rest, [{:min, minute} | acc], count + 2)
end
:else ->
{:error, "Expected minute between 0-60, but got `#{minute}` instead.", count}
end
end
def parse_extended(<<m1::utf8, _::binary>>, :minute, _acc, count),
do: {:error, "Expected 2 digit minute, but got `#{<<m1::utf8>>}` instead.", count}
def parse_extended(_, :minute, _acc, count),
do: {:error, "Expected 2 digit minute.", count}
# Seconds are optional
# Has fractional seconds
def parse_extended(<<s1::utf8, s2::utf8, ".", rest::binary>>, :second, acc, count)
when s1 >= ?0 and s1 < ?6 and
s2 >= ?0 and s2 <= ?9 do
case parse_fractional_seconds(rest, count, <<>>) do
{:ok, fraction, count, rest} ->
seconds = String.to_integer(<<s1::utf8, s2::utf8>>)
precision = byte_size(fraction)
fraction = if precision > 6, do: binary_part(fraction, 0, 6), else: fraction
precision = if precision > 6, do: 6, else: precision
fractional = String.to_integer(fraction)
fractional = fractional * div(1_000_000, trunc(:math.pow(10, precision)))
cond do
seconds >= 0 and seconds <= 60 ->
parse_offset(
rest,
[{:sec_fractional, {fractional, precision}}, {:sec, seconds} | acc],
count + 2
)
:else ->
{:error, "Expected second between 0-60, but got `#{seconds}` instead.", count}
end
{:error, _reason, _count} = err ->
err
end
end
# No fractional seconds
def parse_extended(<<s1::utf8, s2::utf8, rest::binary>>, :second, acc, count)
when s1 >= ?0 and s1 < ?6 and
s2 >= ?0 and s2 <= ?9 do
second = String.to_integer(<<s1::utf8, s2::utf8>>)
cond do
second >= 0 and second <= 60 ->
parse_offset(rest, [{:sec, second} | acc], count + 2)
:else ->
{:error, "Expected second between 0-60, but got `#{second}` instead.", count}
end
end
def parse_extended(<<h::utf8, _::binary>>, :second, _acc, count),
do: {:error, "Expected valid value for seconds, but got `#{<<h::utf8>>}` instead.", count}
def parse_extended(_, :second, _acc, count),
do: {:error, "Expected valid value for seconds.", count}
def parse_fractional_seconds(<<digit::utf8, rest::binary>>, count, acc)
when digit >= ?0 and digit <= ?9 do
parse_fractional_seconds(rest, count + 1, <<acc::binary, digit::utf8>>)
end
def parse_fractional_seconds(_rest, count, "") do
{:error, "Expected at least one digit after the decimal sign, but found none", count}
end
def parse_fractional_seconds(rest, count, acc) do
{:ok, acc, count, rest}
end
def parse_offset(<<"Z", rest::binary>>, acc, count),
do: {:ok, [{:zname, "Etc/UTC"} | acc], count + 1, rest}
def parse_offset(<<dir::utf8, rest::binary>>, acc, count) when dir in [?+, ?-] do
parse_offset(dir, rest, acc, count + 1)
end
def parse_offset("", acc, count), do: {:ok, acc, count, ""}
def parse_offset(str, _acc, count),
do: {:error, "Expected either Z or a valid timezone offset, but got `#{str}`", count}
# +/-HH:MM:SS (seconds are currently unhandled in offsets)
def parse_offset(
dir,
<<h1::utf8, h2::utf8, ":", m1::utf8, m2::utf8, ":", s1::utf8, s2::utf8, rest::binary>>,
acc,
count
)
when h1 >= ?0 and h1 < ?2 and
h2 >= ?0 and h2 <= ?9 and
m1 >= ?0 and m1 < ?6 and
m2 >= ?0 and m2 <= ?9 and
s1 >= ?0 and s1 < ?6 and
s2 >= ?0 and s2 <= ?9 do
{:ok, [{:zname, <<dir::utf8, h1::utf8, h2::utf8, ":", m1::utf8, m2::utf8>>} | acc], count + 7,
rest}
end
# +/-HH:MM
def parse_offset(dir, <<h1::utf8, h2::utf8, ":", m1::utf8, m2::utf8, rest::binary>>, acc, count)
when h1 >= ?0 and h1 < ?2 and
h2 >= ?0 and h2 <= ?9 and
m1 >= ?0 and m1 < ?6 and
m2 >= ?0 and m2 <= ?9 do
{:ok, [{:zname, <<dir::utf8, h1::utf8, h2::utf8, ":", m1::utf8, m2::utf8>>} | acc], count + 5,
rest}
end
# +/-HHMM
def parse_offset(dir, <<h1::utf8, h2::utf8, m1::utf8, m2::utf8, rest::binary>>, acc, count)
when h1 >= ?0 and h1 < ?2 and
h2 >= ?0 and h2 <= ?9 and
m1 >= ?0 and m1 < ?6 and
m2 >= ?0 and m2 <= ?9 do
{:ok, [{:zname, <<dir::utf8, h1::utf8, h2::utf8, ":", m1::utf8, m2::utf8>>} | acc], count + 5,
rest}
end
# +/-HH
def parse_offset(dir, <<h1::utf8, h2::utf8, rest::binary>>, acc, count)
when h1 >= ?0 and h1 < ?2 and
h2 >= ?0 and h2 <= ?9 do
{:ok, [{:zname, <<dir::utf8, h1::utf8, h2::utf8, ":00">>} | acc], count + 2, rest}
end
def parse_offset(_, <<h::utf8, _rest::binary>>, _acc, count),
do: {:error, "Expected valid offset, but got `#{<<h::utf8>>}` instead.", count}
end
