├── .gitattributes
├── config
    ├── config.exs
    ├── dev.exs
    ├── bench.exs
    └── test.exs
├── images
    └── taxjar_sponsor.jpg
├── .formatter.exs
├── lib
    ├── parse_error.ex
    ├── parser
    │   ├── date_us.ex
    │   ├── date_time_us.ex
    │   ├── tokenizer.ex
    │   ├── time.ex
    │   ├── date.ex
    │   ├── epoch.ex
    │   ├── serial.ex
    │   └── date_time.ex
    ├── parser.ex
    ├── formatters.ex
    ├── date_time_parser.ex
    ├── combinators.ex.exs
    └── date_time_parser
    │   ├── timezone_parser.ex
    │   └── timezone_abbreviations.ex
├── test
    ├── test_helper.exs
    ├── support
    │   ├── recorder.ex
    │   └── macros.ex
    ├── fixture
    │   ├── playground_header.md
    │   ├── date_formats_samples.txt
    │   └── ruby-dates.csv
    └── date_time_parser
    │   └── timezone_parser_test.exs
├── CONTRIBUTING.md
├── bench
    ├── profile.exs
    ├── self.exs
    ├── ruby.rb
    └── rails.rb
├── bin
    └── release
├── .gitignore
├── pages
    ├── upgrading_0_to_1.md
    └── Future-UTC-DateTime.md
├── LICENSE.md
├── .github
    └── workflows
    │   └── ci.yml
├── priv
    └── tzdata2022g
    │   ├── etcetera
    │   ├── antarctica
    │   └── backward
├── CODE_OF_CONDUCT.md
├── mix.exs
├── CHANGELOG.md
├── .credo.exs
├── mix.lock
├── README.md
└── EXAMPLES.livemd


/.gitattributes:
--------------------------------------------------------------------------------
1 | lib/combinators.ex binary
2 | 


--------------------------------------------------------------------------------
/config/config.exs:
--------------------------------------------------------------------------------
1 | import Config
2 | 
3 | import_config "#{config_env()}.exs"
4 | 


--------------------------------------------------------------------------------
/config/dev.exs:
--------------------------------------------------------------------------------
1 | import Config
2 | 
3 | config :elixir, :time_zone_database, Tz.TimeZoneDatabase
4 | 


--------------------------------------------------------------------------------
/config/bench.exs:
--------------------------------------------------------------------------------
1 | import Config
2 | 
3 | config :elixir, :time_zone_database, Tz.TimeZoneDatabase
4 | 


--------------------------------------------------------------------------------
/config/test.exs:
--------------------------------------------------------------------------------
1 | import Config
2 | 
3 | config :elixir, :time_zone_database, Tz.TimeZoneDatabase
4 | 


--------------------------------------------------------------------------------
/images/taxjar_sponsor.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dbernheisel/date_time_parser/HEAD/images/taxjar_sponsor.jpg


--------------------------------------------------------------------------------
/.formatter.exs:
--------------------------------------------------------------------------------
1 | # Used by "mix format"
2 | [
3 |   inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
4 | ]
5 | 


--------------------------------------------------------------------------------
/lib/parse_error.ex:
--------------------------------------------------------------------------------
1 | defmodule DateTimeParser.ParseError do
2 |   @moduledoc "An error when parsing fails"
3 | 
4 |   defexception [:message]
5 | end
6 | 


--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
 1 | alias DateTimeParserTest.Recorder
 2 | 
 3 | {:ok, _recorder_pid} = Recorder.start_link()
 4 | 
 5 | write_examples = fn
 6 |   %{excluded: excluded, skipped: skipped} when excluded > 0 or skipped > 0 ->
 7 |     :ok
 8 | 
 9 |   _ ->
10 |     Recorder.write_results()
11 | end
12 | 
13 | if Version.match?(System.version(), ">= 1.8.0"), do: ExUnit.after_suite(write_examples)
14 | ExUnit.start()
15 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributing
 2 | 
 3 | Do not submit PRs with compiled nimble parsec artifacts. The maintainer
 4 | will generate these accordingly before a release.
 5 | 
 6 | To run tests:
 7 | ```shell
 8 | $ # This will run tests, regenerate EXAMPLES.livemd,
 9 | $ # and run Credo in strict mode.
10 | $ mix tests
11 | ```
12 | 
13 | To build a release:
14 | ```shell
15 | $ # bin/release {old_version} {new_version}
16 | $ bin/release 1.1.3 1.1.4
17 | ```
18 | 
19 | Please review and agree to the [code of conduct](./CODE_OF_CONDUCT.md) before
20 | contributing.
21 | 


--------------------------------------------------------------------------------
/bench/profile.exs:
--------------------------------------------------------------------------------
 1 | defmodule Profiler do
 2 |   import ExProf.Macro
 3 |   require DateTimeParser
 4 | 
 5 |   def run(samples) do
 6 |     {results, _return} = profile do
 7 |       Enum.map(samples, &DateTimeParser.parse_datetime/1)
 8 |     end
 9 | 
10 |     results
11 |     |> Enum.sort_by(fn %{time: total_time, percent: total_percent, us_per_call: call_cost} ->
12 |       [total_time, total_percent, call_cost]
13 |     end)
14 |     |> Enum.reverse()
15 |     |> Enum.take(10)
16 |     |> IO.inspect(label: "TOP OFFENDERS")
17 |   end
18 | end
19 | 
20 | samples = "test/fixture/date_formats_samples.txt" |> File.read!() |> String.split("\n")
21 | Profiler.run(samples)
22 | 


--------------------------------------------------------------------------------
/bin/release:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | # Usage: ./bin/release {old_version} {new_version}
 3 | set -e
 4 | 
 5 | previous_version="${1}"
 6 | release_version="${2}"
 7 | 
 8 | mix tests
 9 | git add EXAMPLES.livemd
10 | git add lib/combinators.ex
11 | 
12 | sed -i "" "s/$previous_version/$release_version/" README.md
13 | sed -i "" "s/$previous_version/$release_version/" mix.exs
14 | sed -i "" "s/unreleased/$release_version ($(date +%F))/" CHANGELOG.md
15 | git add mix.exs
16 | git add README.md
17 | git add CHANGELOG.md
18 | 
19 | git commit
20 | git tag -a "$release_version" -m "Release version $release_version"
21 | git push origin "$release_version"
22 | 
23 | mix hex.build
24 | mix hex.publish
25 | 


--------------------------------------------------------------------------------
/lib/parser/date_us.ex:
--------------------------------------------------------------------------------
 1 | defmodule DateTimeParser.Parser.DateUS do
 2 |   @moduledoc """
 3 |   Tokenizes the string for date formats. This prioritizes the US format for representing dates.
 4 |   """
 5 |   @behaviour DateTimeParser.Parser
 6 |   alias DateTimeParser.Combinators
 7 | 
 8 |   @impl DateTimeParser.Parser
 9 |   def preflight(parser), do: {:ok, parser}
10 | 
11 |   @impl DateTimeParser.Parser
12 |   def parse(%{string: string} = parser) do
13 |     case Combinators.parse_date_us(string) do
14 |       {:ok, tokens, _, _, _, _} ->
15 |         DateTimeParser.Parser.Date.from_tokens(parser, tokens)
16 | 
17 |       _ ->
18 |         {:error, :failed_to_parse}
19 |     end
20 |   end
21 | end
22 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build/
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover/
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps/
 9 | 
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 | 
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 | 
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 | 
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 | 
22 | # Ignore package tarball (built via "mix hex.build").
23 | date_time_parser-*.tar
24 | *.benchee
25 | .tool-versions
26 | 


--------------------------------------------------------------------------------
/lib/parser/date_time_us.ex:
--------------------------------------------------------------------------------
 1 | defmodule DateTimeParser.Parser.DateTimeUS do
 2 |   @moduledoc """
 3 |   Tokenizes the string for both date and time formats. This prioritizes the US format for
 4 |   representing dates.
 5 |   """
 6 |   @behaviour DateTimeParser.Parser
 7 | 
 8 |   alias DateTimeParser.Combinators
 9 | 
10 |   @impl DateTimeParser.Parser
11 |   def preflight(parser), do: {:ok, parser}
12 | 
13 |   @impl DateTimeParser.Parser
14 |   def parse(%{string: string} = parser) do
15 |     case Combinators.parse_datetime_us(string) do
16 |       {:ok, tokens, _, _, _, _} ->
17 |         DateTimeParser.Parser.DateTime.from_tokens(parser, tokens)
18 | 
19 |       _ ->
20 |         {:error, :failed_to_parse}
21 |     end
22 |   end
23 | end
24 | 


--------------------------------------------------------------------------------
/bench/self.exs:
--------------------------------------------------------------------------------
 1 | require DateTimeParser
 2 | 
 3 | Benchee.run(%{
 4 |   "parse_datetime" => fn input ->
 5 |     Enum.map(input, &DateTimeParser.parse_datetime/1)
 6 |   end,
 7 | 
 8 |   "parse_date" => fn input ->
 9 |     Enum.map(input, &DateTimeParser.parse_date/1)
10 |   end,
11 | 
12 |   "parse_time" => fn input ->
13 |     Enum.map(input, &DateTimeParser.parse_time/1)
14 |   end
15 | }, [
16 |   inputs: %{
17 |     "date_formats_samples.txt" =>
18 |       "test/fixture/date_formats_samples.txt"
19 |       |> File.read!()
20 |       |> String.split("\n")
21 |   },
22 |   save: [file: "benchmark.benchee", tag: Date.to_iso8601(DateTime.utc_now())],
23 |   load: "benchmark.benchee",
24 |   after_scenario: fn input ->
25 |     input
26 |     |> Enum.reduce(0, fn i, errors ->
27 |       case DateTimeParser.parse_datetime(i) do
28 |         {:ok, _} -> errors
29 |         {:error, _} -> errors + 1
30 |       end
31 |     end)
32 |     |> IO.inspect(label: "Failed to parse")
33 |   end
34 | ])
35 | 


--------------------------------------------------------------------------------
/pages/upgrading_0_to_1.md:
--------------------------------------------------------------------------------
 1 | # Upgrading from 0.x to 1.0
 2 | 
 3 | * If you use `parse_datetime/1`, then change to `parse_datetime/2` with the
 4 |   second argument as a keyword list to `assume_time: true` and `to_utc: true`.
 5 |   In 0.x, it would merge `~T[00:00:00]` if the time tokens could not be parsed;
 6 |   in 1.x, you have to opt into this behavior. Also in 0.x, a non-UTC timezone
 7 |   would automatically convert to UTC; in 1.x, the original timezone will be
 8 |   kept instead.
 9 | * If you use `parse_date/1`, then change to `parse_date/2` with the second
10 |   argument as a keyword list to `assume_date: true`. In 0.x, it would merge
11 |   `Date.utc_today()` with the found date tokens; in 1.x, you need to opt into
12 |   this behavior.
13 | * If you use `parse_time`, there is no breaking change but parsing has been
14 |   improved.
15 | * Not a breaking change, but 1.x introduces `parse/2` that will return the best
16 |   struct from the tokens. This may influence your usage.
17 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2018 David Bernheisel
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/bench/ruby.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'bundler/inline'
 4 | 
 5 | gemfile do
 6 |   source 'https://rubygems.org'
 7 |   gem 'benchmark-ips'
 8 | end
 9 | 
10 | require 'time'
11 | require 'benchmark/ips'
12 | 
13 | puts "\nBenchmarking Ruby Time.parse"
14 | samples = File.read('test/fixture/date_formats_samples.txt').split("\n").freeze
15 | could_not_parse = 0
16 | 
17 | Benchmark.ips do |x|
18 |   x.time = 5
19 |   x.warmup = 2
20 |   x.report('Time.parse') do
21 |     could_not_parse = 0
22 |     samples.map do |v|
23 |       begin
24 |         Time.parse(v)
25 |       rescue ArgumentError
26 |         could_not_parse += 1
27 |       end
28 |     end
29 |   end
30 | 
31 |   x.report('Date.parse') do
32 |     could_not_parse = 0
33 |     samples.map do |v|
34 |       begin
35 |         Date.parse(v)
36 |       rescue ArgumentError
37 |         could_not_parse += 1
38 |       end
39 |     end
40 |   end
41 | 
42 |   x.report('DateTime.parse') do
43 |     could_not_parse = 0
44 |     samples.map do |v|
45 |       begin
46 |         DateTime.parse(v)
47 |       rescue ArgumentError
48 |         could_not_parse += 1
49 |       end
50 |     end
51 |   end
52 | 
53 |   x.compare!
54 | end
55 | 
56 | puts "Failed to parse #{could_not_parse}"
57 | 


--------------------------------------------------------------------------------
/bench/rails.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'bundler/inline'
 4 | 
 5 | gemfile do
 6 |   source 'https://rubygems.org'
 7 |   gem 'activesupport', '= 4.2.9'
 8 |   gem 'benchmark-ips'
 9 | end
10 | 
11 | require 'time'
12 | require 'benchmark/ips'
13 | require 'active_support'
14 | require 'active_support/core_ext/date_time'
15 | 
16 | puts "\nBenchmarking Ruby Time.parse with ActiveSupport"
17 | samples = File.read('test/fixture/date_formats_samples.txt').split("\n").freeze
18 | could_not_parse = 0
19 | 
20 | Benchmark.ips do |x|
21 |   x.config(time: 5, warmup: 2)
22 | 
23 |   x.report('Time.parse') do
24 |     could_not_parse = 0
25 |     samples.map do |v|
26 |       begin
27 |         Time.parse(v)
28 |       rescue ArgumentError
29 |         nil
30 |       end
31 |     end
32 |   end
33 | 
34 |   x.report('Date.parse') do
35 |     could_not_parse = 0
36 |     samples.map do |v|
37 |       begin
38 |         Date.parse(v)
39 |       rescue ArgumentError
40 |         could_not_parse += 1
41 |       end
42 |     end
43 |   end
44 | 
45 |   x.report('DateTime.parse') do
46 |     could_not_parse = 0
47 |     samples.map do |v|
48 |       begin
49 |         DateTime.parse(v)
50 |       rescue ArgumentError
51 |         could_not_parse += 1
52 |       end
53 |     end
54 |   end
55 | 
56 |   x.compare!
57 | end
58 | 
59 | puts "Failed to parse #{could_not_parse}"
60 | 


--------------------------------------------------------------------------------
/lib/parser/tokenizer.ex:
--------------------------------------------------------------------------------
 1 | defmodule DateTimeParser.Parser.Tokenizer do
 2 |   @moduledoc """
 3 |   This parser doesn't parse, instead it checks the string and assigns the appropriate parser during
 4 |   preflight. The appropriate parser is determined by whether there is a `"/"` present in the string,
 5 |   and if so it will assume the string is a US-formatted date or datetime, and therefore use the
 6 |   US-optimized tokenizer module (ie, `DateTimeParser.Parser.DateUS` or
 7 |   `DateTimeParser.Parser.DateTimeUS`) for them. Time will always be parsed with
 8 |   `DateTimeParser.Parser.Time`.
 9 |   """
10 |   @behaviour DateTimeParser.Parser
11 | 
12 |   alias DateTimeParser.Parser
13 | 
14 |   @impl DateTimeParser.Parser
15 |   def preflight(%{string: string, context: context} = parser) do
16 |     {:ok, %{parser | mod: get_token_parser(context, string)}}
17 |   end
18 | 
19 |   @impl DateTimeParser.Parser
20 |   def parse(_parser) do
21 |     raise DateTimeParser.ParseError, "Cannot parse with DateTimeParser.Parser.Tokenizer"
22 |   end
23 | 
24 |   defp get_token_parser(:datetime, string) do
25 |     if String.contains?(string, "/") do
26 |       Parser.DateTimeUS
27 |     else
28 |       Parser.DateTime
29 |     end
30 |   end
31 | 
32 |   defp get_token_parser(:date, string) do
33 |     if String.contains?(string, "/") do
34 |       Parser.DateUS
35 |     else
36 |       Parser.Date
37 |     end
38 |   end
39 | 
40 |   defp get_token_parser(:time, _string) do
41 |     Parser.Time
42 |   end
43 | end
44 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Tests
 3 | 
 4 | on:
 5 |   pull_request:
 6 |     branches:
 7 |       - main
 8 | 
 9 | jobs:
10 |   style:
11 |     runs-on: ubuntu-latest
12 |     name: Check Style
13 |     env:
14 |       MIX_ENV: test
15 |       CI: "true"
16 |     steps:
17 |       - uses: actions/checkout@v4
18 |       - uses: erlef/setup-beam@v1
19 |         with:
20 |           otp-version: '27'
21 |           elixir-version: '1.18.4'
22 |       - run: mix deps.get --only dev
23 |       - run: mix format --check-formatted
24 |       - run: mix credo --strict
25 | 
26 |   test-oldest:
27 |     runs-on: windows-2022
28 |     name: Tests on oldest version
29 |     env:
30 |       MIX_ENV: test
31 |       CI: "true"
32 |     steps:
33 |       - uses: actions/checkout@v4
34 |       - uses: erlef/setup-beam@v1
35 |         with:
36 |           otp-version: '22'
37 |           elixir-version: '1.12.3-otp-22'
38 |       - run: rm mix.lock
39 |       - run: mix deps.get
40 |       - run: mix compile --force --warnings-as-errors
41 |       - run: mix compile.nimble
42 |       - run: mix test
43 | 
44 |   test:
45 |     runs-on: ubuntu-latest
46 |     name: Tests on latest version
47 |     env:
48 |       MIX_ENV: test
49 |       CI: "true"
50 |     steps:
51 |       - uses: actions/checkout@v4
52 |       - uses: erlef/setup-beam@v1
53 |         with:
54 |           otp-version: '27'
55 |           elixir-version: '1.18.4'
56 |       - run: rm mix.lock
57 |       - run: mix deps.get
58 |       - run: mix compile --force --warnings-as-errors
59 |       - run: mix compile.nimble
60 |       - run: mix test
61 | 


--------------------------------------------------------------------------------
/test/support/recorder.ex:
--------------------------------------------------------------------------------
 1 | defmodule DateTimeParserTest.Recorder do
 2 |   @moduledoc "Record results from tests into a Markdown file"
 3 |   @external_resource "test/fixture/playground_header.md"
 4 | 
 5 |   if Version.match?(System.version(), ">= 1.5.0") do
 6 |     use Agent
 7 |     @name {:global, :recorder}
 8 |     @examples_header File.read!(@external_resource)
 9 |     @example_file "EXAMPLES.livemd"
10 | 
11 |     def start_link(initial_value \\ []) do
12 |       Agent.start_link(fn -> initial_value end, name: @name)
13 |     end
14 | 
15 |     def add(input, output, method, opts) do
16 |       Agent.update(@name, fn state ->
17 |         [{input, output, method, opts} | state]
18 |       end)
19 |     end
20 | 
21 |     def list do
22 |       Agent.get(@name, fn state ->
23 |         Enum.sort(state)
24 |       end)
25 |     end
26 | 
27 |     def write_results do
28 |       write_headers()
29 |       Enum.each(list(), &write_result/1)
30 | 
31 |       :ok
32 |     end
33 | 
34 |     defp write_headers do
35 |       File.write(@example_file, @examples_header)
36 |     end
37 | 
38 |     defp write_result({input, output, method, opts}) do
39 |       File.write(
40 |         @example_file,
41 |         "|`#{input}`|`#{DateTimeParserTestMacros.to_iso(output)}`|#{method}|#{format_options(opts)}|\n",
42 |         [:append]
43 |       )
44 |     end
45 | 
46 |     defp format_options([]), do: " "
47 |     defp format_options(options), do: "`#{inspect(options)}`"
48 |   else
49 |     def start_link(_ \\ []), do: {:ok, nil}
50 |     def add(_, _, _, _), do: :ok
51 |     def list, do: :ok
52 |     def write_results, do: :ok
53 |   end
54 | end
55 | 


--------------------------------------------------------------------------------
/test/fixture/playground_header.md:
--------------------------------------------------------------------------------
 1 | # DateTimeParser Playground
 2 | 
 3 | ## Installation
 4 | 
 5 | Install DateTimeParser in your project
 6 | 
 7 | ```elixir
 8 | Mix.install([:date_time_parser, :tz])
 9 | Application.put_env(:elixir, :time_zone_database, Tz.TimeZoneDatabase)
10 | ```
11 | 
12 | ## Usage
13 | 
14 | Use DateTimeParser to parse strings into DateTime, NaiveDateTime, Date, or Time
15 | structs. For example:
16 | 
17 | ```elixir
18 | [
19 |   DateTimeParser.parse_datetime("2021-11-09T10:30:00Z"),
20 |   DateTimeParser.parse_datetime("2021-11-09T10:30:00"),
21 |   DateTimeParser.parse_date("2021-11-09T10:30:00Z"),
22 |   DateTimeParser.parse_time("2021-11-09T10:30:00Z"),
23 |   DateTimeParser.parse("2021-32-32T10:30:00Z"),
24 |   DateTimeParser.parse("2021-11-09T10:30:00Z"),
25 |   DateTimeParser.parse("2021-11-09T10:30:00 EST")
26 | ]
27 | ```
28 | 
29 | or use the bang functions:
30 | 
31 | ```elixir
32 | [
33 |   DateTimeParser.parse_datetime!("2021-11-09T10:30:00Z"),
34 |   DateTimeParser.parse_datetime!("2021-11-09T10:30:00"),
35 |   DateTimeParser.parse_date!("2021-11-09T10:30:00Z"),
36 |   DateTimeParser.parse_time!("2021-11-09T10:30:00Z"),
37 |   DateTimeParser.parse!("2021-32-32T10:30:00Z"),
38 |   DateTimeParser.parse!("2021-11-09T10:30:00Z"),
39 |   DateTimeParser.parse!("2021-11-09T10:30:00 EST")
40 | ]
41 | ```
42 | 
43 | Errors sometimes occur when it can't parse the input:
44 | 
45 | ```elixir
46 | [
47 |   DateTimeParser.parse("wat"),
48 |   DateTimeParser.parse(123),
49 |   DateTimeParser.parse([:foo])
50 | ]
51 | ```
52 | 
53 | ## Options
54 | 
55 | You can configure some convenient options as well, for example to automatically
56 | convert to UTC or to assume a time when not present.
57 | 
58 | ```elixir
59 | [
60 |   DateTimeParser.parse("12:30PM", assume_date: Date.utc_today()),
61 |   DateTimeParser.parse("2022-01-01", assume_time: ~T[12:43:00]),
62 |   DateTimeParser.parse("2022-01-01T15:30 EST", to_utc: true),
63 |   DateTimeParser.parse("2022-01-01T15:30 EST", to_utc: false),
64 |   # Excel time
65 |   DateTimeParser.parse("30134"),
66 |   # old Mac Excel spreadsheet time
67 |   DateTimeParser.parse("30134.4321", use_1904_date_system: true)
68 | ]
69 | ```
70 | 
71 | ## Examples
72 | 
73 | |**Input**|**Output (ISO 8601)**|**Method**|**Options**|
74 | |:-------:|:-------------------:|:--------:|:---------:|
75 | 


--------------------------------------------------------------------------------
/lib/parser/time.ex:
--------------------------------------------------------------------------------
 1 | defmodule DateTimeParser.Parser.Time do
 2 |   @moduledoc """
 3 |   Tokenizes the string for time elements. This will also attempt to extract the time out of the
 4 |   string first before tokenizing to reduce noise in an attempt to be more accurate. For example,
 5 | 
 6 |   ```elixir
 7 |   iex> DateTimeParser.parse_time("Hello Johnny 5, it's 9:30PM")
 8 |   {:ok, ~T[21:30:00]}
 9 |   ```
10 | 
11 |   This will use a regex to extract the part of the string that looks like time, ie, `"9:30PM"`
12 |   """
13 |   @behaviour DateTimeParser.Parser
14 |   @time_regex ~r|(?<time>\d{1,2}:\d{2}(?::\d{2})?(?:.*)?)|
15 | 
16 |   alias DateTimeParser.Combinators
17 |   import DateTimeParser.Formatters, only: [format_token: 2]
18 | 
19 |   @impl DateTimeParser.Parser
20 |   def preflight(parser), do: {:ok, parser}
21 | 
22 |   @impl DateTimeParser.Parser
23 |   def parse(%{string: string} = parser) do
24 |     case string |> extract_time() |> Combinators.parse_time() do
25 |       {:ok, tokens, _, _, _, _} -> from_tokens(parser, tokens)
26 |       _ -> {:error, :failed_to_parse}
27 |     end
28 |   end
29 | 
30 |   defp from_tokens(%{context: context, opts: opts}, tokens) do
31 |     case Time.new(
32 |            format_token(tokens, :hour) || 0,
33 |            format_token(tokens, :minute) || 0,
34 |            format_token(tokens, :second) || 0,
35 |            format_token(tokens, :microsecond) || {0, 0}
36 |          ) do
37 |       {:ok, time} -> for_context(context, time, Keyword.get(opts, :assume_date, false))
38 |       _ -> {:error, "Could not parse time"}
39 |     end
40 |   end
41 | 
42 |   @doc false
43 |   def parsed_time?(parsed_values) do
44 |     Enum.all?([parsed_values[:hour], parsed_values[:minute]])
45 |   end
46 | 
47 |   defp extract_time(string) do
48 |     case Regex.named_captures(@time_regex, string) do
49 |       %{"time" => time} -> time
50 |       _ -> string
51 |     end
52 |   end
53 | 
54 |   defp for_context(:best, time, %Date{} = date), do: NaiveDateTime.new(date, time)
55 |   defp for_context(:best, time, _), do: {:ok, time}
56 |   defp for_context(:time, time, _), do: {:ok, time}
57 |   defp for_context(:date, time, _), do: {:error, "Could not parse a date from #{inspect(time)}"}
58 | 
59 |   defp for_context(:datetime, time, _),
60 |     do: {:error, "Could not parse a datetime from #{inspect(time)}"}
61 | end
62 | 


--------------------------------------------------------------------------------
/test/fixture/date_formats_samples.txt:
--------------------------------------------------------------------------------
  1 |  01 Feb 2013
  2 |  03 Jan 2013 10:15:26 -0800
  3 |  10/1/2018  :: AM
  4 |  11 Feb 2013
  5 |  11 Jan 2013 13:26:55 -0800
  6 |  12/26/2016
  7 |  24 Sep 2013
  8 | 00:00.0
  9 | 01-01-2018
 10 | 01-Feb-18
 11 | 01-Jul
 12 | 01-Jul-18
 13 | 01.09.2018
 14 | 01.11.2018
 15 | 01/01/17
 16 | 01/01/2017
 17 | 01/01/2018 - 17:06
 18 | 01/01/2018 01:21PM
 19 | 01/01/2018 14:44
 20 | 01/01/2018 6:22
 21 | 01/02/16
 22 | 01/02/18 01:02 AM
 23 | 01/02/2015
 24 | 01/Jun./2018
 25 | 02-05-2018
 26 | 02-Oct-17
 27 | 02/01/17
 28 | 02/01/2018
 29 | 02/21/2018  9:37:42 AM
 30 | 03/5/2018
 31 | 05/01/2018 0:00
 32 | 06/14/2018 09:42:08 AM-0500
 33 | 06/28/18 1:25
 34 | 07:09.3
 35 | 08:53.0
 36 | 1-Apr
 37 | 1//1/17
 38 | 1/1/0117
 39 | 1/1/17 19:12
 40 | 1/1/18 00:01
 41 | 1/1/18 3:24 PM
 42 | 1/1/19 10:39 AM
 43 | 1/1/2013
 44 | 1/10/2018  8:38pM
 45 | 1/17/2018 0:00:00
 46 | 1/2/2018 18:06:26
 47 | 1/3/2019 12:00:00 AM
 48 | 1/31/2018 0:00:00 UTC
 49 | 10/2/2017 - 23:14
 50 | 10/5/2017 23:52
 51 | 10:13.7
 52 | 18-07-2018 20:38:34 +00:00
 53 | 18-12-29
 54 | 19-Dec-19
 55 | 2011-01-01 04:19:20 -0:00
 56 | 2012-10-30 09:52:00
 57 | 2012-11-23T22:42:25-05:00
 58 | 2013-04-26 11:25:03 UTC
 59 | 2013-09-10 22:14:56.717
 60 | 2013-12-31T22:18:50+00:00
 61 | 2015-09-28 10:57:11 -0700
 62 | 2015/12/1 1:16
 63 | 2016-04-30
 64 | 2016-05-02T01:10:06+00:00
 65 | 2016-06-11 15:50:43
 66 | 2016-06-16 06:06:06
 67 | 2016-07-01 01:51:34+00
 68 | 2016-07-31 18:42:46-07:00
 69 | 2016-08-04T07:00:25Z
 70 | 2016-08-19 09:34:51.0
 71 | 2016-11-17 10:36:34.81
 72 | 2016-11-23T16:25:33.971897
 73 | 2016/1/9
 74 | 2017-09-29+00:00
 75 | 2017-10-06+03:45:16
 76 | 2017-10-24 04:00:10 PDT
 77 | 2017-12-01 03:52
 78 | 2017/08/08
 79 | 2019/01/31 0:01
 80 | 20190118 949 CST
 81 | 29/Aug./2018
 82 | 29/Sep./2018
 83 | 9/10/2018 11:08:13 AM
 84 | 9/19/2018 20:38
 85 | 9/20/2017 18:57:24 UTC
 86 | =\"10/1/2018\"
 87 | =\"9/5/2018\"
 88 | Apr 1, 2016 12:02:53 AM PDT
 89 | Apr 1, 2017 2:21:25 AM PDT
 90 | Dec 1, 2018 7:39:53 AM PST
 91 | Fri Mar  2 09:01:57 2018
 92 | Fri Mar 31 2017 21:41:40 GMT+0000 (UTC)
 93 | Friday 02 February 2018 10:42:21 AM
 94 | Jan 1, 2013 06:34:31 PM PST
 95 | Jan 1, 2014 6:44:47 AM PST
 96 | Jan-01-19
 97 | Jan-01-2018
 98 | Monday 01 October 2018 06:34:19 AM
 99 | Monday 02 October 2017 9:04:49 AM
100 | Nov 16, 2017 9:41:28 PM PST
101 | Nov 20, 2016 22:09:23 PM
102 | Sat, 29 Sep 2018 21:36:28 -0400
103 | September 28, 2016
104 | Sun Jan 08 2017 04:28:42 GMT+0000 (UTC)
105 | Sun Jul  1 00:31:18 2018
106 | Sunday 01 January 2017 09:22:46 AM
107 | Sunday 01 January 2017 10:11:02 PM
108 | Thu Aug 09 2018 17:13:43 GMT+0000 (UTC)
109 | Thu Feb 08 00:24:33 2018
110 | Thu Jul  5 12:19:56 2018
111 | Thursday 30 August 2018 11:31:18 AM
112 | Tue Jul 31 06:44:39 2018
113 | Tuesday 11 July 2017 1:43:46 PM
114 | Tuesday, November 29, 2016
115 | jul-10-18
116 | 


--------------------------------------------------------------------------------
/lib/parser/date.ex:
--------------------------------------------------------------------------------
 1 | defmodule DateTimeParser.Parser.Date do
 2 |   @moduledoc """
 3 |   Tokenizes the string for date formats. This prioritizes the international standard for
 4 |   representing dates.
 5 |   """
 6 |   @behaviour DateTimeParser.Parser
 7 |   alias DateTimeParser.Combinators
 8 |   import DateTimeParser.Formatters, only: [format_token: 2, clean: 1]
 9 | 
10 |   @impl DateTimeParser.Parser
11 |   def preflight(parser), do: {:ok, parser}
12 | 
13 |   @impl DateTimeParser.Parser
14 |   def parse(%{string: string} = parser) do
15 |     case Combinators.parse_date(string) do
16 |       {:ok, tokens, _, _, _, _} -> from_tokens(parser, tokens)
17 |       _ -> {:error, :failed_to_parse}
18 |     end
19 |   end
20 | 
21 |   @doc false
22 |   def from_tokens(%{context: context, opts: opts}, tokens) do
23 |     parsed_values =
24 |       clean(%{
25 |         year: format_token(tokens, :year),
26 |         month: format_token(tokens, :month),
27 |         day: format_token(tokens, :day)
28 |       })
29 | 
30 |     with {:ok, date} <-
31 |            for_context(context, parsed_values, Keyword.get(opts, :assume_date, false)) do
32 |       validate_day(date)
33 |     end
34 |   end
35 | 
36 |   @type dayable ::
37 |           DateTime.t()
38 |           | NaiveDateTime.t()
39 |           | Date.t()
40 |           | %{day: Calendar.day(), month: Calendar.month(), year: Calendar.year()}
41 | 
42 |   @doc "Validate either the Date or [Naive]DateTime has a valid day"
43 |   @spec validate_day(dayable) :: {:ok, dayable} | :error
44 |   def validate_day(%{day: day, month: month} = date)
45 |       when month in [1, 3, 5, 7, 8, 10, 12] and day in 1..31,
46 |       do: {:ok, date}
47 | 
48 |   def validate_day(%{day: day, month: month} = date)
49 |       when month in [4, 6, 9, 11] and day in 1..30,
50 |       do: {:ok, date}
51 | 
52 |   def validate_day(%{day: day, month: 2} = date)
53 |       when day in 1..28,
54 |       do: {:ok, date}
55 | 
56 |   def validate_day(%{day: 29, month: 2, year: _} = date) do
57 |     if Date.leap_year?(date), do: {:ok, date}, else: :error
58 |   end
59 | 
60 |   def validate_day(_), do: :error
61 | 
62 |   @doc false
63 |   def parsed_date?(parsed_values) do
64 |     Enum.all?([parsed_values[:year], parsed_values[:month], parsed_values[:day]])
65 |   end
66 | 
67 |   defp for_context(:best, result, assume_date) do
68 |     DateTimeParser.Parser.first_ok(
69 |       [
70 |         fn -> for_context(:date, result, assume_date) end
71 |       ],
72 |       "Could not parse a date"
73 |     )
74 |   end
75 | 
76 |   defp for_context(:date, parsed_values, true),
77 |     do: {:ok, Map.merge(Date.utc_today(), parsed_values)}
78 | 
79 |   defp for_context(:date, parsed_values, %Date{} = date),
80 |     do: {:ok, Map.merge(date, parsed_values)}
81 | 
82 |   defp for_context(:date, parsed_values, _) do
83 |     if parsed_date?(parsed_values) do
84 |       Date.new(parsed_values[:year], parsed_values[:month], parsed_values[:day])
85 |     else
86 |       {:error, :cannot_assume_date}
87 |     end
88 |   end
89 | 
90 |   defp for_context(:time, _parsed_values, _), do: {:error, "Could not parse a time out of a date"}
91 | 
92 |   defp for_context(:datetime, _parsed_values, _),
93 |     do: {:error, "Could not parse a datetime out of a date"}
94 | end
95 | 


--------------------------------------------------------------------------------
/priv/tzdata2022g/etcetera:
--------------------------------------------------------------------------------
 1 | # tzdb data for ships at sea and other miscellany
 2 | 
 3 | # This file is in the public domain, so clarified as of
 4 | # 2009-05-17 by Arthur David Olson.
 5 | 
 6 | # These entries are for uses not otherwise covered by the tz database.
 7 | # Their main practical use is for platforms like Android that lack
 8 | # support for POSIX-style TZ strings.  On such platforms these entries
 9 | # can be useful if the timezone database is wrong or if a ship or
10 | # aircraft at sea is not in a timezone.
11 | 
12 | # Starting with POSIX 1003.1-2001, the entries below are all
13 | # unnecessary as settings for the TZ environment variable.  E.g.,
14 | # instead of TZ='Etc/GMT+4' one can use the POSIX setting TZ='<-04>+4'.
15 | #
16 | # Do not use a POSIX TZ setting like TZ='GMT+4', which is four hours
17 | # behind GMT but uses the completely misleading abbreviation "GMT".
18 | 
19 | # The following zone is used by tzcode functions like gmtime,
20 | # which load the "UTC" file to handle seconds properly.
21 | Zone	Etc/UTC		0	-	UTC
22 | 
23 | # Functions like gmtime load the "GMT" file to handle leap seconds properly.
24 | # Vanguard section, which works with most .zi parsers.
25 | #Zone	GMT		0	-	GMT
26 | # Rearguard section, for TZUpdater 2.3.2 and earlier.
27 | Zone	Etc/GMT		0	-	GMT
28 | 
29 | # The following link uses older naming conventions,
30 | # but it belongs here, not in the file 'backward',
31 | # as it is needed for tzcode releases through 2022a,
32 | # where functions like gmtime load "GMT" instead of the "Etc/UTC".
33 | # We want this to work even on installations that omit 'backward'.
34 | Link	Etc/GMT				GMT
35 | # End of rearguard section.
36 | 
37 | # Be consistent with POSIX TZ settings in the Zone names,
38 | # even though this is the opposite of what many people expect.
39 | # POSIX has positive signs west of Greenwich, but many people expect
40 | # positive signs east of Greenwich.  For example, TZ='Etc/GMT+4' uses
41 | # the abbreviation "-04" and corresponds to 4 hours behind UT
42 | # (i.e. west of Greenwich) even though many people would expect it to
43 | # mean 4 hours ahead of UT (i.e. east of Greenwich).
44 | 
45 | # Earlier incarnations of this package were not POSIX-compliant,
46 | # and had lines such as
47 | #		Zone	GMT-12		-12	-	GMT-1200
48 | # We did not want things to change quietly if someone accustomed to the old
49 | # way does a
50 | #		zic -l GMT-12
51 | # so we moved the names into the Etc subdirectory.
52 | # Also, the time zone abbreviations are now compatible with %z.
53 | 
54 | Zone	Etc/GMT-14	14	-	+14
55 | Zone	Etc/GMT-13	13	-	+13
56 | Zone	Etc/GMT-12	12	-	+12
57 | Zone	Etc/GMT-11	11	-	+11
58 | Zone	Etc/GMT-10	10	-	+10
59 | Zone	Etc/GMT-9	9	-	+09
60 | Zone	Etc/GMT-8	8	-	+08
61 | Zone	Etc/GMT-7	7	-	+07
62 | Zone	Etc/GMT-6	6	-	+06
63 | Zone	Etc/GMT-5	5	-	+05
64 | Zone	Etc/GMT-4	4	-	+04
65 | Zone	Etc/GMT-3	3	-	+03
66 | Zone	Etc/GMT-2	2	-	+02
67 | Zone	Etc/GMT-1	1	-	+01
68 | Zone	Etc/GMT+1	-1	-	-01
69 | Zone	Etc/GMT+2	-2	-	-02
70 | Zone	Etc/GMT+3	-3	-	-03
71 | Zone	Etc/GMT+4	-4	-	-04
72 | Zone	Etc/GMT+5	-5	-	-05
73 | Zone	Etc/GMT+6	-6	-	-06
74 | Zone	Etc/GMT+7	-7	-	-07
75 | Zone	Etc/GMT+8	-8	-	-08
76 | Zone	Etc/GMT+9	-9	-	-09
77 | Zone	Etc/GMT+10	-10	-	-10
78 | Zone	Etc/GMT+11	-11	-	-11
79 | Zone	Etc/GMT+12	-12	-	-12
80 | 


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | # Code of Conduct
 2 | 
 3 | ## Our Pledge
 4 | 
 5 | In the interest of fostering an open and welcoming environment, we as
 6 | contributors and maintainers pledge to making participation in our project and
 7 | our community a harassment-free experience for everyone, regardless of age, body
 8 | size, disability, ethnicity, sex characteristics, gender identity and expression,
 9 | level of experience, education, socio-economic status, nationality, personal
10 | appearance, race, religion, or sexual identity and orientation.
11 | 
12 | ## Our Standards
13 | 
14 | Examples of behavior that contributes to creating a positive environment
15 | include:
16 | 
17 | * Using welcoming and inclusive language
18 | * Being respectful of differing viewpoints and experiences
19 | * Gracefully accepting constructive criticism
20 | * Focusing on what is best for the community
21 | * Showing empathy towards other community members
22 | 
23 | Examples of unacceptable behavior by participants include:
24 | 
25 | * The use of sexualized language or imagery and unwelcome sexual attention or
26 |   advances
27 | * Trolling, insulting/derogatory comments, and personal or political attacks
28 | * Public or private harassment
29 | * Publishing others' private information, such as a physical or electronic
30 |   address, without explicit permission
31 | * Other conduct which could reasonably be considered inappropriate in a
32 |   professional setting
33 | 
34 | ## Our Responsibilities
35 | 
36 | Project maintainers are responsible for clarifying the standards of acceptable
37 | behavior and are expected to take appropriate and fair corrective action in
38 | response to any instances of unacceptable behavior.
39 | 
40 | Project maintainers have the right and responsibility to remove, edit, or
41 | reject comments, commits, code, wiki edits, issues, and other contributions
42 | that are not aligned to this Code of Conduct, or to ban temporarily or
43 | permanently any contributor for other behaviors that they deem inappropriate,
44 | threatening, offensive, or harmful.
45 | 
46 | ## Scope
47 | 
48 | This Code of Conduct applies within all project spaces, and it also applies when
49 | an individual is representing the project or its community in public spaces.
50 | Examples of representing a project or community include using an official
51 | project e-mail address, posting via an official social media account, or acting
52 | as an appointed representative at an online or offline event. Representation of
53 | a project may be further defined and clarified by project maintainers.
54 | 
55 | ## Enforcement
56 | 
57 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
58 | reported by contacting the project team at david@bernheisel.com. All
59 | complaints will be reviewed and investigated and will result in a response that
60 | is deemed necessary and appropriate to the circumstances. The project team is
61 | obligated to maintain confidentiality with regard to the reporter of an incident.
62 | Further details of specific enforcement policies may be posted separately.
63 | 
64 | Project maintainers who do not follow or enforce the Code of Conduct in good
65 | faith may face temporary or permanent repercussions as determined by other
66 | members of the project's leadership.
67 | 
68 | ## Attribution
69 | 
70 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
71 | available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
72 | 
73 | [homepage]: https://www.contributor-covenant.org
74 | 
75 | For answers to common questions about this code of conduct, see
76 | https://www.contributor-covenant.org/faq
77 | 


--------------------------------------------------------------------------------
/pages/Future-UTC-DateTime.md:
--------------------------------------------------------------------------------
 1 | # Future DateTime UTC timestamps
 2 | 
 3 | If you are certain that all of your timestamps are in the past, then you can
 4 | safely ignore this guide.
 5 | 
 6 | If you are working with timestamps that are in the future, and those timestamps
 7 | are inside countries with governing bodies that have the ability to change
 8 | timezone rules, including daylight savings, then you may want to consider your
 9 | timestamp storage strategy. Shortly, it's not foolproof to convert the timestamp
10 | to UTC and store only that DateTime.
11 | 
12 | ## Rules Change
13 | 
14 | Consider this scenario: It's currently year 2019 and you receive a timestamp for
15 | a user located in Washington, USA for July 4, 2022. You convert it to UTC and
16 | store it in your database.
17 | 
18 | Today (in year 2019), Washington state recognizes Daylight Savings Time and it
19 | shifts back and forth an hour over the year. Since the timestamp is in the
20 | summer, it's shifted forward an hour.
21 | 
22 | In 2020, Washington enacts a new law that declares that they will no longer be
23 | participate in Daylight Savings Time; meaning it's always shifted back one
24 | hour year-round.
25 | 
26 | You've already stored your timestamps in the future converted to UTC using the
27 | old rules. How do you know to fix all your timestamps in your database for users
28 | in Washington state?
29 | 
30 | ## What is our context?
31 | 
32 | There are 3 elements at play:
33 | 
34 | 1. You need a consistent timestamp field for database queries (opposed to
35 |    strings). Usually this is UTC timestamps.
36 | 2. The user provided a timestamp based on their location, and looked at the
37 |    clock on their desk when filling in the form in your web app.
38 | 3. The provided timestamp is based on the location the user is in, and that
39 |    location follows a set of rules of how time changes throughout the year.
40 | 
41 | We need to store timestamps in a database column made for timestamps so we can
42 | achieve #1. This can be more complicated given your database, but using Postgres
43 | as an example, it internally converts to UTC and queries against that. If you're
44 | using Ecto as your data mapper, it must always be in UTC before storage.
45 | 
46 | If the law changes between now and the future timestamp, we've lost the correct
47 | wall time for the user in #2.
48 | 
49 | When we immediately convert to UTC, we lose the context in #3.
50 | 
51 | ## Storage Strategy
52 | 
53 | Store the user's provided timestamp and timezone separately from the converted
54 | UTC. For example:
55 | 
56 | ```elixir
57 | field :my_timestamp_utc, :utc_datetime
58 | field :my_timestamp_tz, :string
59 | field :my_timestamp_wall, :naive_datetime
60 | ```
61 | 
62 | Since we're making `my_timestamp_utc` a `:utc_datetime`, we are affirming we
63 | have the timezone information of UTC. Since we're making `my_timestamp_wall` a
64 | `:naive_datetime`, we're affirming we do not have the timezone.
65 | 
66 | Once you have these 3 pieces of context, you can periodically update and verify
67 | changes. It would be good to update your UTC timestamps whenever your tzdata
68 | files are updated. If the walltime + timezone is reconverted to UTC and is
69 | different from your stored UTC timestamp, then you know the rules have changed
70 | since storage. Update the UTC timestamp and perhaps notify the customer to
71 | ensure the intentions are still correct (for example, did they already know of
72 | the upcoming law change and anticipate it?).
73 | 
74 | ## Credits
75 | 
76 | [http://www.creativedeletion.com/2015/03/19/persisting_future_datetimes.html](http://www.creativedeletion.com/2015/03/19/persisting_future_datetimes.html)
77 | 


--------------------------------------------------------------------------------
/test/date_time_parser/timezone_parser_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule DateTimeParser.TimezoneParserTest do
 2 |   use ExUnit.Case, async: true
 3 | 
 4 |   alias DateTimeParser.TimezoneParser
 5 | 
 6 |   describe "parsing zones" do
 7 |     test "parses a zone" do
 8 |       sample = """
 9 |       Zone America/New_York	-4:56:02 -	LMT	1883 Nov 18 17:00u
10 |       			-5:00	US	E%sT	1920
11 |       			-5:00	NYC	E%sT	1942
12 |       			-5:00	US	E%sT	1946
13 |       			-5:00	NYC	E%sT	1967
14 |       			-5:00	US	E%sT
15 |       """
16 | 
17 |       {[zone1, zone2, zone3, zone4, zone5, zone6] = zones, []} = TimezoneParser.parse(sample)
18 |       assert Enum.all?(zones, &(&1.name == "America/New_York"))
19 |       assert zone1.utc_offset_sec == -17_762
20 |       assert zone1.utc_offset_hrs == "-0456"
21 |       assert zone1.abbreviations == ["LMT"]
22 |       assert zone1.from == nil
23 |       assert zone1.until == ~U[1883-11-18 17:00:00Z]
24 | 
25 |       assert Enum.all?([zone2, zone3, zone4, zone5, zone6], &(&1.utc_offset_sec == -18_000))
26 |       assert Enum.all?([zone2, zone3, zone4, zone5, zone6], &(&1.utc_offset_hrs == "-0500"))
27 |       assert Enum.all?([zone2, zone3, zone4, zone5, zone6], &(&1.abbreviations == []))
28 |       assert zone2.from == ~U[1883-11-18 17:00:00Z]
29 |       assert zone2.until == ~N[1920-01-01 00:00:00]
30 |       assert zone3.from == ~N[1920-01-01 00:00:00]
31 |       assert zone3.until == ~N[1942-01-01 00:00:00]
32 |       assert zone4.from == ~N[1942-01-01 00:00:00]
33 |       assert zone4.until == ~N[1946-01-01 00:00:00]
34 |       assert zone5.from == ~N[1946-01-01 00:00:00]
35 |       assert zone5.until == ~N[1967-01-01 00:00:00]
36 |       assert zone6.from == ~N[1967-01-01 00:00:00]
37 |       refute zone6.until
38 |     end
39 | 
40 |     test "parses rules" do
41 |       sample = """
42 |       Rule	US	1918	1919	-	Mar	lastSun	2:00	1:00	D
43 |       Rule	US	1918	1919	-	Oct	lastSun	2:00	0	S
44 |       Rule	US	1942	only	-	Feb	9	2:00	1:00	W # War
45 |       Rule	US	1945	only	-	Aug	14	23:00u	1:00	P # Peace
46 |       Rule	US	1945	only	-	Sep	30	2:00	0	S
47 |       Rule	US	1967	2006	-	Oct	lastSun	2:00	0	S
48 |       Rule	US	1967	1973	-	Apr	lastSun	2:00	1:00	D
49 |       Rule	US	1974	only	-	Jan	6	2:00	1:00	D
50 |       Rule	US	1975	only	-	Feb	lastSun	2:00	1:00	D
51 |       Rule	US	1976	1986	-	Apr	lastSun	2:00	1:00	D
52 |       Rule	US	1987	2006	-	Apr	Sun>=1	2:00	1:00	D
53 |       Rule	US	2007	max	-	Mar	Sun>=8	2:00	1:00	D
54 |       Rule	US	2007	max	-	Nov	Sun>=1	2:00	0	S
55 |       Rule	NYC	1920	only	-	Mar	lastSun	2:00	1:00	D
56 |       Rule	NYC	1920	only	-	Oct	lastSun	2:00	0	S
57 |       Rule	NYC	1921	1966	-	Apr	lastSun	2:00	1:00	D
58 |       Rule	NYC	1921	1954	-	Sep	lastSun	2:00	0	S
59 |       Rule	NYC	1955	1966	-	Oct	lastSun	2:00	0	S
60 |       """
61 | 
62 |       {[], rules} = TimezoneParser.parse(sample)
63 |       [rule1, rule2, rule3 | _] = rules |> Enum.sort_by(&{&1.name, &1.from})
64 | 
65 |       # Rule	NYC	1921	1966	-	Apr	lastSun	2:00	1:00	D
66 |       assert rule1.name == "NYC"
67 |       assert rule1.from == ~N[1921-04-24 02:00:00]
68 |       assert rule1.until == ~N[1966-04-24 02:00:00]
69 |       assert rule1.save == 3600
70 |       assert rule1.letter == "D"
71 | 
72 |       # Rule	NYC	1921	1954	-	Sep	lastSun	2:00	0	S
73 |       assert rule2.name == "NYC"
74 |       assert rule2.from == ~N[1921-09-25 02:00:00]
75 |       assert rule2.until == ~N[1954-09-26 02:00:00]
76 |       assert rule2.save == 0
77 |       assert rule2.letter == "S"
78 | 
79 |       # Rule	NYC	1920	only	-	Mar	lastSun	2:00	1:00	D
80 |       assert rule3.name == "NYC"
81 |       assert rule3.from == ~N[1920-03-28 02:00:00]
82 |       assert rule3.until == ~N[1920-03-28 02:00:00]
83 |       assert rule3.save == 3600
84 |       assert rule3.letter == "D"
85 |     end
86 |   end
87 | end
88 | 


--------------------------------------------------------------------------------
/lib/parser.ex:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParser.Parser do
  2 |   @moduledoc """
  3 |   Interface for the DateTimeParser to use when parsing a string.
  4 | 
  5 |   The flow is:
  6 | 
  7 |   1. Preflight the string to see if the parser is appropriate. Sometimes the parsing can happen at
  8 |     this stage if it's a simple parser, for example it can be done in a single regex. Results of the
  9 |     preflight, if needed, can be stored in the `struct.preflight`.
 10 |   2. Parse the string. You have `t:context/0` to check if you should return a time, date, or datetime.
 11 |     Also make sure you're honoring the user's options supplied in `struct.opts`
 12 | 
 13 |   You may create your own parser and use it with the DateTimeParser by creating a module that
 14 |   follows this behaviour.
 15 |   """
 16 | 
 17 |   defstruct [:string, :mod, :preflight, :context, opts: []]
 18 | 
 19 |   @type context :: :datetime | :date | :time | :best
 20 |   @type t :: %__MODULE__{
 21 |           string: String.t(),
 22 |           mod: module(),
 23 |           context: context(),
 24 |           preflight: any(),
 25 |           opts: Keyword.t()
 26 |         }
 27 | 
 28 |   alias DateTimeParser.Parser
 29 |   require Logger
 30 | 
 31 |   @doc """
 32 |   Determine if the string is appropriate to parse with this parser. If not, then other parsers will
 33 |   be attempted.
 34 |   """
 35 |   @callback preflight(t()) :: {:ok, t()} | {:error, :not_compatible}
 36 | 
 37 |   @doc """
 38 |   Parse the string.
 39 |   """
 40 |   @callback parse(t()) ::
 41 |               {:ok, DateTime.t() | NaiveDateTime.t() | Time.t() | Date.t()} | {:error, any()}
 42 | 
 43 |   @default_parsers [Parser.Epoch, Parser.Serial, Parser.Tokenizer]
 44 |   @builtin_parsers @default_parsers ++
 45 |                      [Parser.DateTime, Parser.DateTimeUS, Parser.Date, Parser.DateUS, Parser.Time]
 46 | 
 47 |   @doc false
 48 |   def builtin_parsers, do: @builtin_parsers
 49 | 
 50 |   @doc false
 51 |   def default_parsers, do: @default_parsers
 52 | 
 53 |   @doc false
 54 |   def build(string, context, opts) do
 55 |     parser = %__MODULE__{context: context, string: string, opts: opts}
 56 | 
 57 |     {parsers, opts} =
 58 |       Keyword.pop(
 59 |         opts,
 60 |         :parsers,
 61 |         Application.get_env(:date_time_parser, :parsers, @default_parsers)
 62 |       )
 63 | 
 64 |     parsers
 65 |     |> Enum.map(&to_parser_mod/1)
 66 |     |> Enum.find_value({:error, :no_parser}, fn parser_mod ->
 67 |       case parser_mod.preflight(parser) do
 68 |         {:ok, parser} ->
 69 |           {:ok,
 70 |            put_new_mod(%{parser | context: opts[:context] || context, opts: opts}, parser_mod)}
 71 | 
 72 |         {:error, _} ->
 73 |           false
 74 |       end
 75 |     end)
 76 |   end
 77 | 
 78 |   defp put_new_mod(%{mod: nil} = parser, mod), do: %{parser | mod: mod}
 79 |   defp put_new_mod(parser, _), do: parser
 80 | 
 81 |   defp to_parser_mod(:tokenizer) do
 82 |     Logger.info("Using :tokenizer is deprecated. Use DateTimeParser.Parser.Tokenizer instead.")
 83 |     Parser.Tokenizer
 84 |   end
 85 | 
 86 |   defp to_parser_mod(:epoch) do
 87 |     Logger.info("Using :epoch is deprecated. Use DateTimeParser.Parser.Epoch instead.")
 88 |     Parser.Epoch
 89 |   end
 90 | 
 91 |   defp to_parser_mod(:serial) do
 92 |     Logger.info("Using :serial is deprecated. Use DateTimeParser.Parser.Serial instead.")
 93 |     Parser.Serial
 94 |   end
 95 | 
 96 |   defp to_parser_mod(mod), do: mod
 97 | 
 98 |   @doc false
 99 |   def first_ok(funs, error_msg) do
100 |     Enum.find_value(
101 |       funs,
102 |       {:error, error_msg},
103 |       fn x ->
104 |         case x.() do
105 |           {:error, _} -> false
106 |           result -> result
107 |         end
108 |       end
109 |     )
110 |   end
111 | end
112 | 


--------------------------------------------------------------------------------
/mix.exs:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParser.MixProject do
  2 |   use Mix.Project
  3 |   @version "1.3.0"
  4 | 
  5 |   def project do
  6 |     [
  7 |       app: :date_time_parser,
  8 |       name: "DateTimeParser",
  9 |       version: @version,
 10 |       homepage_url: "https://hexdocs.pm/date_time_parser",
 11 |       source_url: "https://github.com/dbernheisel/date_time_parser",
 12 |       elixir: ">= 1.12.0",
 13 |       elixirc_paths: elixirc_paths(Mix.env()),
 14 |       aliases: aliases(),
 15 |       package: package(),
 16 |       docs: docs(),
 17 |       start_permanent: Mix.env() == :prod,
 18 |       preferred_cli_env: [
 19 |         tests: :test,
 20 |         benchmark: :bench,
 21 |         profile: :bench
 22 |       ],
 23 |       deps: deps(),
 24 |       description: "Parse a string into DateTime, NaiveDateTime, Time, or Date struct."
 25 |     ]
 26 |   end
 27 | 
 28 |   def application do
 29 |     [
 30 |       extra_applications: [:logger]
 31 |     ]
 32 |   end
 33 | 
 34 |   defp elixirc_paths(:test), do: ["lib", "test/support"]
 35 |   defp elixirc_paths(_), do: ["lib"]
 36 | 
 37 |   defp package do
 38 |     [
 39 |       files: [
 40 |         "lib",
 41 |         "mix.exs",
 42 |         "CODE_OF_CONDUCT*",
 43 |         "CHANGELOG*",
 44 |         "README*",
 45 |         "LICENSE*",
 46 |         "EXAMPLES*",
 47 |         "priv/tzdata*/*"
 48 |       ],
 49 |       maintainers: ["David Bernheisel"],
 50 |       licenses: ["MIT"],
 51 |       links: %{
 52 |         "GitHub" => "https://github.com/dbernheisel/date_time_parser",
 53 |         "Readme" => "https://github.com/dbernheisel/date_time_parser/blob/#{@version}/README.md",
 54 |         "Changelog" =>
 55 |           "https://github.com/dbernheisel/date_time_parser/blob/#{@version}/CHANGELOG.md"
 56 |       }
 57 |     ]
 58 |   end
 59 | 
 60 |   defp deps() do
 61 |     [
 62 |       {:exprof, "~> 0.2.0", only: :bench},
 63 |       {:kday, "~> 1.0", runtime: false},
 64 |       {:benchee, "~> 1.0", only: [:bench], runtime: false},
 65 |       {:tz, "~> 0.24", only: [:dev, :test, :bench], runtime: false},
 66 |       {:credo, "~> 1.1", only: [:dev, :test], runtime: false},
 67 |       {:ex_doc, "~> 0.20", only: :dev, warn_if_outdated: true, runtime: false},
 68 |       {:nimble_parsec, "~> 1.4", only: [:dev, :test], runtime: false}
 69 |     ]
 70 |   end
 71 | 
 72 |   defp docs() do
 73 |     [
 74 |       main: "DateTimeParser",
 75 |       source_ref: @version,
 76 |       extras: [
 77 |         "pages/Future-UTC-DateTime.md",
 78 |         "CHANGELOG.md",
 79 |         "EXAMPLES.livemd",
 80 |         "LICENSE.md"
 81 |       ]
 82 |     ]
 83 |   end
 84 | 
 85 |   defp tests() do
 86 |     []
 87 |     |> add_if("compile --force --warnings-as-errors", !System.get_env("CI"))
 88 |     |> add_if("compile.nimble", !System.get_env("CI"))
 89 |     |> add_if("format --check-formatted", true)
 90 |     |> add_if("credo --strict", true)
 91 |     |> add_if("test", true)
 92 |   end
 93 | 
 94 |   defp aliases() do
 95 |     [
 96 |       "compile.nimble": [
 97 |         "cmd rm -f lib/combinators.ex",
 98 |         "nimble_parsec.compile lib/combinators.ex.exs",
 99 |         "compile"
100 |       ],
101 |       tests: tests(),
102 |       profile: ["run bench/profile.exs"],
103 |       benchmark: [
104 |         "run bench/self.exs",
105 |         "cmd ruby bench/ruby.rb",
106 |         "cmd ruby bench/rails.rb"
107 |       ]
108 |     ]
109 |   end
110 | 
111 |   defp add_if(commands, command, true), do: commands ++ [command]
112 |   defp add_if(commands, _command, ""), do: commands
113 | 
114 |   defp add_if(commands, command, version) when is_binary(version) do
115 |     add_if(commands, command, Version.match?(System.version(), version))
116 |   end
117 | 
118 |   defp add_if(commands, _command, _), do: commands
119 | end
120 | 


--------------------------------------------------------------------------------
/lib/parser/epoch.ex:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParser.Parser.Epoch do
  2 |   @moduledoc """
  3 |   Parses a Unix Epoch timestamp. This is gated by the number of present digits. It must contain 10
  4 |   or 11 seconds, with an optional subsecond up to 10 digits. Negative epoch timestamps are
  5 |   supported.
  6 |   """
  7 |   @behaviour DateTimeParser.Parser
  8 | 
  9 |   @max_subsecond_digits 6
 10 |   @one_second_in_microseconds (1 * :math.pow(10, 6)) |> trunc()
 11 |   @epoch_regex ~r|\A(?<sign>-)?(?<seconds>\d{10,11})(?:\.(?<subseconds>\d{1,10}))?\z|
 12 | 
 13 |   @impl DateTimeParser.Parser
 14 |   def preflight(%{string: string} = parser) do
 15 |     case Regex.named_captures(@epoch_regex, string) do
 16 |       nil -> {:error, :not_compatible}
 17 |       results -> {:ok, %{parser | preflight: results}}
 18 |     end
 19 |   end
 20 | 
 21 |   @impl DateTimeParser.Parser
 22 |   def parse(%{preflight: preflight} = parser) do
 23 |     %{"sign" => sign, "seconds" => raw_seconds, "subseconds" => raw_subseconds} = preflight
 24 |     is_negative = sign == "-"
 25 |     has_subseconds = raw_subseconds != ""
 26 | 
 27 |     with {:ok, seconds} <- parse_seconds(raw_seconds, is_negative, has_subseconds),
 28 |          {:ok, subseconds} <- parse_subseconds(raw_subseconds, is_negative) do
 29 |       from_tokens(parser, {seconds, subseconds})
 30 |     end
 31 |   end
 32 | 
 33 |   @spec parse_seconds(String.t(), boolean(), boolean()) ::
 34 |           {:ok, integer()}
 35 |   defp parse_seconds(raw_seconds, is_negative, has_subseconds)
 36 | 
 37 |   defp parse_seconds(raw_seconds, true, true) do
 38 |     with {:ok, seconds} <- parse_seconds(raw_seconds, true, false) do
 39 |       {:ok, seconds - 1}
 40 |     end
 41 |   end
 42 | 
 43 |   defp parse_seconds(raw_seconds, true, false) do
 44 |     with {:ok, seconds} <- parse_seconds(raw_seconds, false, false) do
 45 |       {:ok, seconds * -1}
 46 |     end
 47 |   end
 48 | 
 49 |   defp parse_seconds(raw_seconds, false, _) do
 50 |     with {seconds, ""} <- Integer.parse(raw_seconds) do
 51 |       {:ok, seconds}
 52 |     end
 53 |   end
 54 | 
 55 |   @spec parse_subseconds(String.t(), boolean()) :: {:ok, {integer(), integer()}}
 56 |   defp parse_subseconds("", _), do: {:ok, {0, 0}}
 57 | 
 58 |   defp parse_subseconds(raw_subseconds, true) do
 59 |     with {:ok, {truncated_microseconds, number_of_subsecond_digits}} <-
 60 |            parse_subseconds(raw_subseconds, false) do
 61 |       negative_truncated_microseconds =
 62 |         if truncated_microseconds > 0 do
 63 |           @one_second_in_microseconds - truncated_microseconds
 64 |         else
 65 |           truncated_microseconds
 66 |         end
 67 | 
 68 |       {:ok, {negative_truncated_microseconds, number_of_subsecond_digits}}
 69 |     end
 70 |   end
 71 | 
 72 |   defp parse_subseconds(raw_subseconds, false) do
 73 |     with {subseconds, ""} <- Float.parse("0.#{raw_subseconds}") do
 74 |       microseconds = (subseconds * :math.pow(10, 6)) |> trunc()
 75 |       precision = min(String.length(raw_subseconds), @max_subsecond_digits)
 76 | 
 77 |       truncated_microseconds =
 78 |         microseconds
 79 |         |> Integer.digits()
 80 |         |> Enum.take(@max_subsecond_digits)
 81 |         |> Integer.undigits()
 82 | 
 83 |       {:ok, {truncated_microseconds, precision}}
 84 |     end
 85 |   end
 86 | 
 87 |   defp from_tokens(%{context: context}, {seconds, {microseconds, precision}}) do
 88 |     truncated_microseconds =
 89 |       microseconds
 90 |       |> Integer.digits()
 91 |       |> Enum.take(@max_subsecond_digits)
 92 |       |> Integer.undigits()
 93 | 
 94 |     with {:ok, datetime} <- DateTime.from_unix(seconds) do
 95 |       for_context(context, %{datetime | microsecond: {truncated_microseconds, precision}})
 96 |     end
 97 |   end
 98 | 
 99 |   defp for_context(:best, result) do
100 |     DateTimeParser.Parser.first_ok(
101 |       [
102 |         fn -> for_context(:datetime, result) end,
103 |         fn -> for_context(:date, result) end,
104 |         fn -> for_context(:time, result) end
105 |       ],
106 |       "cannot convert #{inspect(result)} to context :best"
107 |     )
108 |   end
109 | 
110 |   defp for_context(:datetime, datetime), do: {:ok, datetime}
111 |   defp for_context(:date, datetime), do: {:ok, DateTime.to_date(datetime)}
112 |   defp for_context(:time, datetime), do: {:ok, DateTime.to_time(datetime)}
113 | 
114 |   defp for_context(context, result) do
115 |     {:error, "cannot convert #{inspect(result)} to context #{context}"}
116 |   end
117 | end
118 | 


--------------------------------------------------------------------------------
/lib/formatters.ex:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParser.Formatters do
  2 |   @moduledoc false
  3 | 
  4 |   def format_token(tokens, :hour) do
  5 |     case {find_token(tokens, :hour), tokens |> find_token(:am_pm) |> format()} do
  6 |       {{:hour, 0}, _} ->
  7 |         0
  8 | 
  9 |       {{:hour, 12}, "AM"} ->
 10 |         0
 11 | 
 12 |       {{:hour, hour}, "PM"} when hour < 12 ->
 13 |         hour + 12
 14 | 
 15 |       {{:hour, hour}, _} ->
 16 |         hour
 17 | 
 18 |       _ ->
 19 |         nil
 20 |     end
 21 |   end
 22 | 
 23 |   def format_token(tokens, :year) do
 24 |     case tokens |> find_token(:year) |> format() do
 25 |       nil ->
 26 |         nil
 27 | 
 28 |       year ->
 29 |         year |> to_4_year() |> String.to_integer()
 30 |     end
 31 |   end
 32 | 
 33 |   def format_token(tokens, token) do
 34 |     tokens |> find_token(token) |> format()
 35 |   end
 36 | 
 37 |   defp find_token(tokens, find_me) do
 38 |     Enum.find(tokens, fn
 39 |       {token, _} -> token == find_me
 40 |       _ -> false
 41 |     end)
 42 |   end
 43 | 
 44 |   # If the parsed two-digit year is 00 to 49, then
 45 |   #  - If the last two digits of the current year are 00 to 49, then the returned year has the same
 46 |   #    first two digits as the current year.
 47 |   #  - If the last two digits of the current year are 50 to 99, then the first 2 digits of the
 48 |   #    returned year are 1 greater than the first 2 digits of the current year.
 49 |   # If the parsed two-digit year is 50 to 99, then
 50 |   #  - If the last two digits of the current year are 00 to 49, then the first 2 digits of the
 51 |   #    returned year are 1 less than the first 2 digits of the current year.
 52 |   #  - If the last two digits of the current year are 50 to 99, then the returned year has the same
 53 |   #    first two digits as the current year.
 54 |   defp to_4_year(parsed_3yr) when byte_size(parsed_3yr) == 3 do
 55 |     [current_millenia | _rest] =
 56 |       DateTime.utc_now()
 57 |       |> Map.get(:year)
 58 |       |> Integer.digits()
 59 | 
 60 |     "#{current_millenia}#{parsed_3yr}"
 61 |   end
 62 | 
 63 |   defp to_4_year(parsed_2yr) when byte_size(parsed_2yr) == 2 do
 64 |     [current_millenia, current_century, current_decade, current_year] =
 65 |       DateTime.utc_now()
 66 |       |> Map.get(:year)
 67 |       |> Integer.digits()
 68 | 
 69 |     parsed_2yr = String.to_integer(parsed_2yr)
 70 |     current_2yr = String.to_integer("#{current_decade}#{current_year}")
 71 | 
 72 |     cond do
 73 |       parsed_2yr < 50 && current_2yr < 50 ->
 74 |         "#{current_millenia}#{current_century}#{parsed_2yr}"
 75 | 
 76 |       parsed_2yr < 50 && current_2yr >= 50 ->
 77 |         [_parsed_millenia, parsed_century] =
 78 |           [current_millenia, current_century]
 79 |           |> Integer.undigits()
 80 |           |> Kernel.+(1)
 81 |           |> Integer.digits()
 82 | 
 83 |         "#{current_millenia}#{parsed_century}#{parsed_2yr}"
 84 | 
 85 |       parsed_2yr >= 50 && current_2yr < 50 ->
 86 |         [parsed_millenia, parsed_century] =
 87 |           [current_millenia, current_century]
 88 |           |> Integer.undigits()
 89 |           |> Kernel.-(1)
 90 |           |> Integer.digits()
 91 | 
 92 |         "#{parsed_millenia}#{parsed_century}#{parsed_2yr}"
 93 | 
 94 |       parsed_2yr >= 50 && current_2yr >= 50 ->
 95 |         "#{current_millenia}#{current_century}#{parsed_2yr}"
 96 |     end
 97 |   end
 98 | 
 99 |   defp to_4_year(parsed_year), do: parsed_year
100 | 
101 |   def format({:microsecond, value}) do
102 |     val = value |> to_string |> String.slice(0, 6)
103 | 
104 |     {
105 |       val |> String.pad_trailing(6, "0") |> String.to_integer(),
106 |       val |> byte_size()
107 |     }
108 |   end
109 | 
110 |   def format({:zone_abbr, value}), do: String.upcase(value)
111 |   def format({:utc_offset, offset}), do: to_string(offset)
112 |   def format({:year, value}), do: to_string(value)
113 |   def format({:am_pm, value}), do: String.upcase(value)
114 |   def format({_, value}) when is_integer(value), do: value
115 |   def format({_, value}), do: String.to_integer(value)
116 |   def format(_), do: nil
117 | 
118 |   def clean(string) when is_binary(string) do
119 |     string
120 |     |> String.trim()
121 |     |> String.replace(" @ ", "T")
122 |     |> String.replace(~r{[[:space:]]+}, " ")
123 |     |> String.replace(" - ", "-")
124 |     |> String.replace("//", "/")
125 |     |> String.replace(~r{=|"|'|,|\\}, "")
126 |     |> String.downcase()
127 |   end
128 | 
129 |   def clean(%{} = map) do
130 |     map
131 |     |> Enum.reject(fn {_k, v} -> is_nil(v) end)
132 |     |> Enum.into(%{})
133 |   end
134 | end
135 | 


--------------------------------------------------------------------------------
/test/fixture/ruby-dates.csv:
--------------------------------------------------------------------------------
  1 |  01 Feb 2013,2013-02-01T05:00:00Z
  2 |  03 Jan 2013 10:15:26 -0800,2013-01-03T18:15:26Z
  3 |  10/1/2018  :: AM,2018-10-01T04:00:00Z
  4 |  11 Feb 2013,2013-02-11T05:00:00Z
  5 |  11 Jan 2013 13:26:55 -0800,2013-01-11T21:26:55Z
  6 |  12/26/2016,2016-12-26T05:00:00Z
  7 |  24 Sep 2013,2013-09-24T04:00:00Z
  8 | 00:00.0,2019-06-19T04:00:00Z
  9 | 01-01-2018,2018-01-01T05:00:00Z
 10 | 01-Feb-18,2018-02-01T05:00:00Z
 11 | 01-Jul,2019-07-01T04:00:00Z
 12 | 01-Jul-18,2018-07-01T04:00:00Z
 13 | 01.09.2018,2018-09-01T04:00:00Z
 14 | 01.11.2018,2018-11-01T04:00:00Z
 15 | 01/01/17,2017-01-01T05:00:00Z
 16 | 01/01/2017,2017-01-01T05:00:00Z
 17 | 01/01/2018 - 17:06,2018-01-01T22:06:00Z
 18 | 01/01/2018 01:21PM,2018-01-01T18:21:00Z
 19 | 01/01/2018 14:44,2018-01-01T19:44:00Z
 20 | 01/01/2018 6:22,2018-01-01T11:22:00Z
 21 | 01/02/16,2016-01-02T05:00:00Z
 22 | 01/02/18 01:02 AM,2018-01-02T06:02:00Z
 23 | 01/02/2015,2015-01-02T05:00:00Z
 24 | 01/Jun./2018,2018-06-01T04:00:00Z
 25 | 02-05-2018,2018-05-02T04:00:00Z
 26 | 02-Oct-17,2017-10-02T04:00:00Z
 27 | 02/01/17,2017-02-01T05:00:00Z
 28 | 02/01/2018,2018-02-01T05:00:00Z
 29 | 02/21/2018  9:37:42 AM,2018-02-21T14:37:42Z
 30 | 03/5/2018,2018-03-05T05:00:00Z
 31 | 05/01/2018 0:00,2018-05-01T04:00:00Z
 32 | 06/14/2018 09:42:08 AM-0500,2018-06-14T14:42:08Z
 33 | 06/28/18 1:25,2018-06-28T05:25:00Z
 34 | 07:09.3,2019-06-19T11:09:00Z
 35 | 08:53.0,2019-06-19T12:53:00Z
 36 | 1-Apr,2019-04-01T04:00:00Z
 37 | 1//1/17,2019-01-17T05:00:00Z
 38 | 1/1/0117,0117-01-01T04:56:02Z
 39 | 1/1/17 19:12,2017-01-02T00:12:00Z
 40 | 1/1/18 00:01,2018-01-01T05:01:00Z
 41 | 1/1/18 3:24 PM,2018-01-01T20:24:00Z
 42 | 1/1/19 10:39 AM,2019-01-01T15:39:00Z
 43 | 1/1/2013,2013-01-01T05:00:00Z
 44 | 1/10/2018  8:38pM,2018-01-11T01:38:00Z
 45 | 1/17/2018 0:00:00,2018-01-17T05:00:00Z
 46 | 1/2/2018 18:06:26,2018-01-02T23:06:26Z
 47 | 1/3/2019 12:00:00 AM,2019-01-03T05:00:00Z
 48 | 1/31/2018 0:00:00 UTC,2018-01-31T00:00:00Z
 49 | 10/2/2017 - 23:14,2017-10-03T03:14:00Z
 50 | 10/5/2017 23:52,2017-10-06T03:52:00Z
 51 | 10:13.7,2019-06-19T14:13:00Z
 52 | 18-07-2018 20:38:34 +00:00,2018-07-18T20:38:34Z
 53 | 18-12-29,2018-12-29T05:00:00Z
 54 | 19-Dec-19,2019-12-19T05:00:00Z
 55 | 2011-01-01 04:19:20 -0:00,2011-01-01T09:19:20Z
 56 | 2012-10-30 09:52:00,2012-10-30T13:52:00Z
 57 | 2012-11-23T22:42:25-05:00,2012-11-24T03:42:25Z
 58 | 2013-04-26 11:25:03 UTC,2013-04-26T11:25:03Z
 59 | 2013-09-10 22:14:56.717,2013-09-11T02:14:56Z
 60 | 2013-12-31T22:18:50+00:00,2013-12-31T22:18:50Z
 61 | 2015-09-28 10:57:11 -0700,2015-09-28T17:57:11Z
 62 | 2015/12/1 1:16,2015-12-01T06:16:00Z
 63 | 2016-04-30,2016-04-30T04:00:00Z
 64 | 2016-05-02T01:10:06+00:00,2016-05-02T01:10:06Z
 65 | 2016-06-11 15:50:43,2016-06-11T19:50:43Z
 66 | 2016-06-16 06:06:06,2016-06-16T10:06:06Z
 67 | 2016-07-01 01:51:34+00,2016-07-01T01:51:34Z
 68 | 2016-07-31 18:42:46-07:00,2016-08-01T01:42:46Z
 69 | 2016-08-04T07:00:25Z,2016-08-04T07:00:25Z
 70 | 2016-08-19 09:34:51.0,2016-08-19T13:34:51Z
 71 | 2016-11-17 10:36:34.81,2016-11-17T15:36:34Z
 72 | 2016-11-23T16:25:33.971897,2016-11-23T21:25:33Z
 73 | 2016/1/9,2016-01-09T05:00:00Z
 74 | 2017-09-29+00:00,2017-09-29T04:00:00Z
 75 | 2017-10-06+03:45:16,2017-10-06T07:45:16Z
 76 | 2017-10-24 04:00:10 PDT,2017-10-24T11:00:10Z
 77 | 2017-12-01 03:52,2017-12-01T08:52:00Z
 78 | 2017/08/08,2017-08-08T04:00:00Z
 79 | 2019/01/31 0:01,2019-01-31T05:01:00Z
 80 | 20190118 949 CST,2019-01-18T05:00:00Z
 81 | 29/Aug./2018,2018-08-29T04:00:00Z
 82 | 29/Sep./2018,2018-09-29T04:00:00Z
 83 | 9/10/2018 11:08:13 AM,2018-09-10T15:08:13Z
 84 | 9/19/2018 20:38,2018-09-20T00:38:00Z
 85 | 9/20/2017 18:57:24 UTC,2017-09-20T18:57:24Z
 86 | "=\""10/1/2018\""",2018-10-01T04:00:00Z
 87 | "=\""9/5/2018\""",2018-09-05T04:00:00Z
 88 | "Apr 1, 2016 12:02:53 AM PDT",2016-04-01T07:02:53Z
 89 | "Apr 1, 2017 2:21:25 AM PDT",2017-04-01T09:21:25Z
 90 | "Dec 1, 2018 7:39:53 AM PST",2018-12-01T15:39:53Z
 91 | Fri Mar  2 09:01:57 2018,2018-03-02T14:01:57Z
 92 | Fri Mar 31 2017 21:41:40 GMT+0000 (UTC),2017-04-01T01:41:40Z
 93 | Friday 02 February 2018 10:42:21 AM,2018-02-02T15:42:21Z
 94 | "Jan 1, 2013 06:34:31 PM PST",2013-01-02T02:34:31Z
 95 | "Jan 1, 2014 6:44:47 AM PST",2014-01-01T14:44:47Z
 96 | Jan-01-19,2019-01-01T05:00:00Z
 97 | Jan-01-2018,2018-01-01T05:00:00Z
 98 | Monday 01 October 2018 06:34:19 AM,2018-10-01T10:34:19Z
 99 | Monday 02 October 2017 9:04:49 AM,2017-10-02T13:04:49Z
100 | "Nov 16, 2017 9:41:28 PM PST",2017-11-17T05:41:28Z
101 | "Nov 20, 2016 22:09:23 PM",2016-11-21T03:09:23Z
102 | "Sat, 29 Sep 2018 21:36:28 -0400",2018-09-30T01:36:28Z
103 | "September 28, 2016",2016-09-28T04:00:00Z
104 | Sun Jan 08 2017 04:28:42 GMT+0000 (UTC),2017-01-08T09:28:42Z
105 | Sun Jul  1 00:31:18 2018,2018-07-01T04:31:18Z
106 | Sunday 01 January 2017 09:22:46 AM,2017-01-01T14:22:46Z
107 | Sunday 01 January 2017 10:11:02 PM,2017-01-02T03:11:02Z
108 | Thu Aug 09 2018 17:13:43 GMT+0000 (UTC),2018-08-09T21:13:43Z
109 | Thu Feb 08 00:24:33 2018,2018-02-08T05:24:33Z
110 | Thu Jul  5 12:19:56 2018,2018-07-05T16:19:56Z
111 | Thursday 30 August 2018 11:31:18 AM,2018-08-30T15:31:18Z
112 | Tue Jul 31 06:44:39 2018,2018-07-31T10:44:39Z
113 | Tuesday 11 July 2017 1:43:46 PM,2017-07-11T17:43:46Z
114 | "Tuesday, November 29, 2016",2016-11-29T05:00:00Z
115 | jul-10-18,2018-07-10T04:00:00Z
116 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | ## 1.3.0 (2025-11-24)
  4 | 
  5 | - Support [day of week] [nth] [month name] [year] format. Thanks @s3cur3 (PR #15)
  6 | 
  7 | ## 1.2.1 (2025-07-23)
  8 | 
  9 | - Fix compiler warnings (floats as +/-)
 10 | - Fix timezone IANA parsing bug when getting the last k day of a month
 11 | 
 12 | ## 1.2.0 (2023-12-06)
 13 | 
 14 | - Drop Timex as dependency. This required a custom IANA file parser for
 15 |   determining timezones and rules that was able to parse timezone abbreviations.
 16 |   Doing so requires the use of Elixir functions introduced in Elixir 1.11.
 17 | - Bump NimbleParsec which requires Elixir 1.12.
 18 | 
 19 | ## 1.1.5 (2022-10-07)
 20 | 
 21 | - Switch to pre-compiled combinators so that NimbleParsec is not needed during
 22 |   compilation-- why have everyone else compile this when we can compile it
 23 |   before publishing?
 24 | - Update examples to be a Livebook
 25 | - Fix serial parser matching on time
 26 | - Fix `assume_date` option with time results from `parse` function.
 27 | - Support Month-Year format; please note that this essentially requires a
 28 |   fallback `assume_date` since there is not a data structure that only describes
 29 |   Month and Year in Elixir.
 30 | 
 31 | ## 1.1.4 (2022-10-05)
 32 | 
 33 | - Update GitHub Repo references
 34 | 
 35 | ## 1.1.3 (2021-10-24)
 36 | 
 37 | - Stricter time parsing by requiring time separators. For example, `949` used to
 38 |   be parsed as `09:49:00`, but is now considered not valid. This is to help
 39 |   decrease false positives of nonsensical times such as `25:00 am` (incorrectly
 40 |   parsed as `02:05:00`). Thanks @fcapovilla (PR #46)
 41 | 
 42 | ## 1.1.2 (2021-06-14)
 43 | 
 44 | - Correct handling of 12:xx:xx AM timestamps (12hr). These were incorrectly
 45 |     parsed as 12:xx:xx (24hr) timestamps when they should have been 00:xx:xx
 46 |     (24hr) timestamps.
 47 | 
 48 | - Lock Timex to >= 3.2.1 and <= 3.7.2 to avoid timezone conversion issues when
 49 |   using `to_utc: true`. Looks like there are some breaking changes (for us)
 50 | 
 51 | ## 1.1.1 (2021-02-06)
 52 | 
 53 | - Adjust tokenizer to prefer month/day before of day/month when those are the
 54 |     only found tokens. Thanks @mwean raising the issue.
 55 | 
 56 | ## 1.1.0 (2020-10-17)
 57 | 
 58 | - Add option `use_1904_date_system` for the serial parser. It defaults to
 59 |     `false`. Most spreadsheet applications use the 1900 date system, but
 60 |     Microsoft Excel on Macintosh in particular used the 1904 date system
 61 |     [@fcapovilla].
 62 | 
 63 | ## 1.0.0 (2020-02-05)
 64 | 
 65 | ### Breaking
 66 | 
 67 | - Change `parse_datetime` to no longer assume time. Previously, it
 68 |     would assume `00:00:00` if it could not be parsed. This is replaced with an
 69 |     opt-in option `assume_time`. See next point. If you relied on this, to
 70 |     upgrade add the option; eg: `DateTimeParser.parse_datetime(string,
 71 |     assume_time: true)`
 72 | - Change `parse_datetime` to no longer convert DateTime to UTC
 73 |     timezone. If you relied on this, to upgrade add the option; eg:
 74 |     `DateTimeParser.parse_datetime(string, to_utc: true)`
 75 | - Change `parse_date` to no longer assume a date. Previously, it
 76 |     would assume the current date, and replace the found information from the
 77 |     string. This is replaced with an opt-in option of `assume_date`. If you
 78 |     relied on this, to upgrade add the option; eg:
 79 |     `DateTimeParser.parse_date(string, assume_date: true)`
 80 | 
 81 | ### Bugs
 82 | 
 83 | - Fix a UTC conversion bug between Daylight/Standard time (#20). If you're
 84 |     using an earlier version and converting to UTC, please upgrade to >=
 85 |     1.0.0-rc2 immediately.
 86 | - Fix an epoch subsecond parsing bug (#16) (thanks @tmr08c)
 87 | - Updated for compatibility with Elixir 1.10.0
 88 | 
 89 | ### Features
 90 | 
 91 | - Add `parse/2` that will respond with the best match. This function accepts all
 92 |     options introduced below.
 93 | - Change `parse_datetime/1` to `parse_datetime/2` to accept options:
 94 |   - `assume_time: true | %Time{} | false` with the default of false.
 95 | - Change `parse_date/1` to `parse_date/2` to accept options:
 96 |   - `assume_date: true | %Date{} | false` with the default of false.
 97 | - Add support for parsing negative epoch times. (#24) (thanks @tmr08c)
 98 | - Add bang variants, `parse!/2`, `parse_datetime!/2`, `parse_time!/2`, and
 99 |     `parse_date!/2`
100 | - Added `parsers: []` option to add or disable parsers. This is helpful if you
101 |     are don't want to consider Serial or Epoch timestamps.
102 | 
103 | ## 0.2.0 (2019-09-26)
104 | 
105 | - Add Serial time support
106 | 
107 | ## 0.1.4 (2019-09-03)
108 | 
109 | - Refactor
110 | - Support subsecond parsing to 24 digits (yoctoseconds) [thanks @myfreeweb]
111 | 
112 | ## 0.1.3 (2019-08-02)
113 | 
114 | - Support parsing Unix epoch times from strings
115 | - Fix microsecond parsing
116 | 
117 | ## 0.1.2 (2019-07-11)
118 | 
119 | - Validate days of month. Previously it would allow invalid days such as Feb 30.
120 |   Now it will check if the year is a leap year and allow up to 29, and otherwise
121 |   28 for Feb. It will also reject day 31 on months without 31 days.
122 | 
123 | ## 0.1.1 (2019-07-03)
124 | 
125 | - Fix PM 12-hr conversion. The bug would convert 12:34PM to 24:34 which is
126 |   not valid
127 | 
128 | ## 0.1.0 (2019-06-24)
129 | 
130 | - Add DateTimeParser.parse_datetime/2
131 | - Add DateTimeParser.parse_date/1
132 | - Add DateTimeParser.parse_time/1
133 | 


--------------------------------------------------------------------------------
/lib/parser/serial.ex:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParser.Parser.Serial do
  2 |   @moduledoc """
  3 |   Parses a spreadsheet Serial timestamp. This is gated by the number of present digits. It must
  4 |   contain 1 through 5 digits that represent days, with an optional precision of up to 10 digits that
  5 |   represents time. Negative serial timestamps are supported.
  6 | 
  7 |   Microsoft Excel has, since its earliest versions, incorrectly considered 1900 to be a leap year,
  8 |   and therefore that February 29, 1900 comes between February 28 and March 1 of that year. The bug
  9 |   originated from Lotus 1-2-3 and was purposely implemented in Excel for the purpose of backward
 10 |   compatibility. Microsoft has written an article about this bug, explaining the reasons for
 11 |   treating 1900 as a leap year. This bug has been promoted into a requirement in the Ecma Office
 12 |   Open XML (OOXML) specification.
 13 | 
 14 |   Microsoft Excel on Macintosh defaults to using the 1904 date system. By default, this parser will
 15 |   assume the 1900. If you want to opt-into the 1904 date system, see the `t:use_1904_date_system`
 16 |   option.
 17 | 
 18 |   See more at https://en.wikipedia.org/wiki/Leap_year_bug
 19 |   """
 20 |   @behaviour DateTimeParser.Parser
 21 |   @serial_regex ~r|\A(?<days>-?\d{1,5})(?:\.(?<time>\d{1,10}))?\z|
 22 | 
 23 |   @impl DateTimeParser.Parser
 24 |   def preflight(%{string: string} = parser) do
 25 |     case Regex.named_captures(@serial_regex, string) do
 26 |       nil -> {:error, :not_compatible}
 27 |       results -> {:ok, %{parser | preflight: results}}
 28 |     end
 29 |   end
 30 | 
 31 |   @impl DateTimeParser.Parser
 32 |   @empty ["", nil]
 33 |   def parse(%{preflight: %{"time" => time, "days" => day}} = parser) when time in @empty do
 34 |     case Integer.parse(day) do
 35 |       {num, ""} -> from_tokens(parser, num)
 36 |       _ -> {:error, :failed_to_parse_integer}
 37 |     end
 38 |   end
 39 | 
 40 |   def parse(%{string: string} = parser) do
 41 |     case Float.parse(string) do
 42 |       {num, ""} -> from_tokens(parser, num)
 43 |       _ -> {:error, :failed_to_parse_float}
 44 |     end
 45 |   end
 46 | 
 47 |   defp from_tokens(%{context: context, opts: opts}, serial) do
 48 |     with serial <- set_date_system(serial, opts),
 49 |          {:ok, date_or_datetime} <- from_serial(serial) do
 50 |       for_context(context, date_or_datetime, opts[:assume_time])
 51 |     end
 52 |   end
 53 | 
 54 |   defp for_context(:best, result, assume_time) do
 55 |     DateTimeParser.Parser.first_ok(
 56 |       [
 57 |         fn -> for_context(:datetime, result, assume_time) end,
 58 |         fn -> for_context(:date, result, assume_time) end,
 59 |         fn -> for_context(:time, result, assume_time) end
 60 |       ],
 61 |       "cannot convert #{inspect(result)} to context :best"
 62 |     )
 63 |   end
 64 | 
 65 |   defp for_context(:datetime, %NaiveDateTime{} = ndt, _), do: {:ok, ndt}
 66 |   defp for_context(:datetime, %Date{} = date, true), do: assume_time(date, ~T[00:00:00])
 67 |   defp for_context(:datetime, %Date{} = date, %Time{} = time), do: assume_time(date, time)
 68 |   defp for_context(:date, %Date{} = date, _), do: {:ok, date}
 69 |   defp for_context(:date, %NaiveDateTime{} = ndt, _), do: {:ok, NaiveDateTime.to_date(ndt)}
 70 |   defp for_context(:time, %NaiveDateTime{} = ndt, _), do: {:ok, NaiveDateTime.to_time(ndt)}
 71 | 
 72 |   defp for_context(context, result, _opts) do
 73 |     {:error, "cannot convert #{inspect(result)} to context #{context}"}
 74 |   end
 75 | 
 76 |   defp from_serial(float) when is_float(float) do
 77 |     {serial_date, serial_time} = split_float(float)
 78 |     erl_time = time_from_serial(serial_time)
 79 |     erl_date = date_from_serial(serial_date)
 80 |     NaiveDateTime.from_erl({erl_date, erl_time})
 81 |   end
 82 | 
 83 |   defp from_serial(integer) when is_integer(integer) do
 84 |     erl_date = date_from_serial(integer)
 85 |     Date.from_erl(erl_date)
 86 |   end
 87 | 
 88 |   defp assume_time(%Date{} = date, %Time{} = time) do
 89 |     NaiveDateTime.new(
 90 |       date.year,
 91 |       date.month,
 92 |       date.day,
 93 |       time.hour,
 94 |       time.minute,
 95 |       time.second,
 96 |       time.microsecond
 97 |     )
 98 |   end
 99 | 
100 |   defp time_from_serial(serial_time) do
101 |     case serial_time do
102 |       zero when zero in [+0.0, -0.0] ->
103 |         {0, 0, 0}
104 | 
105 |       serial_time ->
106 |         {hours, min_fraction} = split_float(serial_time * 24)
107 |         {minutes, sec_fraction} = split_float(min_fraction * 60)
108 |         {seconds, _microseconds} = split_float(sec_fraction * 60)
109 | 
110 |         {hours, minutes, seconds}
111 |     end
112 |   end
113 | 
114 |   defp date_from_serial(serial_date) do
115 |     {1899, 12, 31}
116 |     |> :calendar.date_to_gregorian_days()
117 |     |> Kernel.+(serial_date)
118 |     |> adjust_for_lotus_bug
119 |     |> :calendar.gregorian_days_to_date()
120 |   end
121 | 
122 |   defp split_float(float) when float >= 0 do
123 |     whole = float |> Float.floor() |> round()
124 |     {whole, float - whole}
125 |   end
126 | 
127 |   defp split_float(float) when float < 0 do
128 |     whole = abs(float) |> Float.floor() |> round()
129 |     fraction = 1 - (abs(float) - whole)
130 |     fraction = if fraction == 1.0, do: +0.0, else: fraction
131 |     {whole * -1, fraction}
132 |   end
133 | 
134 |   defp adjust_for_lotus_bug(day) when day > 59, do: day - 1
135 |   defp adjust_for_lotus_bug(day), do: day
136 | 
137 |   defp set_date_system(serial, opts) do
138 |     if Keyword.get(opts, :use_1904_date_system, false), do: serial + 1462, else: serial
139 |   end
140 | end
141 | 


--------------------------------------------------------------------------------
/lib/parser/date_time.ex:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParser.Parser.DateTime do
  2 |   @moduledoc """
  3 |   Tokenizes the string for both date and time formats. This prioritizes the international standard
  4 |   for representing dates.
  5 |   """
  6 |   @behaviour DateTimeParser.Parser
  7 |   alias DateTimeParser.Combinators
  8 |   alias DateTimeParser.TimezoneAbbreviations
  9 |   import DateTimeParser.Formatters, only: [format_token: 2, clean: 1]
 10 | 
 11 |   @impl DateTimeParser.Parser
 12 |   def preflight(parser), do: {:ok, parser}
 13 | 
 14 |   @impl DateTimeParser.Parser
 15 |   def parse(%{string: string} = parser) do
 16 |     case Combinators.parse_datetime(string) do
 17 |       {:ok, tokens, _, _, _, _} -> from_tokens(parser, tokens)
 18 |       _ -> {:error, :failed_to_parse}
 19 |     end
 20 |   end
 21 | 
 22 |   @doc false
 23 |   def from_tokens(%{opts: opts}, tokens) do
 24 |     parsed_values =
 25 |       clean(%{
 26 |         year: format_token(tokens, :year),
 27 |         month: format_token(tokens, :month),
 28 |         day: format_token(tokens, :day),
 29 |         hour: format_token(tokens, :hour),
 30 |         minute: format_token(tokens, :minute),
 31 |         second: format_token(tokens, :second),
 32 |         microsecond: format_token(tokens, :microsecond)
 33 |       })
 34 | 
 35 |     with true <- DateTimeParser.Parser.Date.parsed_date?(parsed_values),
 36 |          {:ok, ndt} <- to_naive_date_time(opts, parsed_values),
 37 |          {:ok, ndt} <- validate_day(ndt),
 38 |          {:ok, dt} <- to_datetime(opts, ndt, tokens) do
 39 |       maybe_convert_to_utc(dt, opts)
 40 |     end
 41 |   end
 42 | 
 43 |   @doc false
 44 |   def validate_day(ndt), do: DateTimeParser.Parser.Date.validate_day(ndt)
 45 | 
 46 |   @doc false
 47 |   def from_naive_datetime_and_tokens(opts, naive_datetime, tokens) do
 48 |     with timezone when not is_nil(timezone) <- tokens[:zone_abbr] || tokens[:utc_offset],
 49 |          {:ok, %{} = timezone_info} <- timezone_from_tokens(tokens, naive_datetime, opts) do
 50 |       naive_datetime
 51 |       |> DateTime.from_naive!("Etc/UTC")
 52 |       |> Map.merge(timezone_info)
 53 |     else
 54 |       _ -> naive_datetime
 55 |     end
 56 |   end
 57 | 
 58 |   @doc """
 59 |   Convert the given NaiveDateTime to a DateTime if the user provided `to_utc: true`. If the result
 60 |   is already in UTC, this will pass through.
 61 |   """
 62 |   def maybe_convert_to_utc(%DateTime{zone_abbr: "Etc/UTC"} = datetime, _opts) do
 63 |     {:ok, datetime}
 64 |   end
 65 | 
 66 |   def maybe_convert_to_utc(%NaiveDateTime{} = naive_datetime, opts) do
 67 |     if Keyword.get(opts, :assume_utc, false) do
 68 |       naive_datetime
 69 |       |> DateTime.from_naive!("Etc/UTC")
 70 |       |> maybe_convert_to_utc(opts)
 71 |     else
 72 |       {:ok, naive_datetime}
 73 |     end
 74 |   end
 75 | 
 76 |   def maybe_convert_to_utc(%DateTime{} = datetime, opts) do
 77 |     if Keyword.get(opts, :to_utc, false) do
 78 |       DateTime.shift_zone(datetime, "Etc/UTC")
 79 |     else
 80 |       {:ok, datetime}
 81 |     end
 82 |   end
 83 | 
 84 |   defp to_naive_date_time(opts, parsed_values) do
 85 |     case Keyword.get(opts, :assume_time, false) do
 86 |       false ->
 87 |         if DateTimeParser.Parser.Time.parsed_time?(parsed_values) do
 88 |           NaiveDateTime.new(
 89 |             parsed_values[:year],
 90 |             parsed_values[:month],
 91 |             parsed_values[:day],
 92 |             parsed_values[:hour],
 93 |             parsed_values[:minute],
 94 |             parsed_values[:second] || 0,
 95 |             parsed_values[:microsecond] || {0, 0}
 96 |           )
 97 |         else
 98 |           {:error, :cannot_assume_time}
 99 |         end
100 | 
101 |       %Time{} = assumed_time ->
102 |         assume_time(parsed_values, assumed_time)
103 | 
104 |       true ->
105 |         assume_time(parsed_values, ~T[00:00:00])
106 |     end
107 |   end
108 | 
109 |   defp assume_time(parsed_values, %Time{} = time) do
110 |     NaiveDateTime.new(
111 |       parsed_values[:year],
112 |       parsed_values[:month],
113 |       parsed_values[:day],
114 |       parsed_values[:hour] || time.hour,
115 |       parsed_values[:minute] || time.minute,
116 |       parsed_values[:second] || time.second,
117 |       parsed_values[:microsecond] || time.microsecond
118 |     )
119 |   end
120 | 
121 |   defp timezone_from_tokens(tokens, naive_datetime, opts) do
122 |     zone = format_token(tokens, :zone_abbr)
123 |     offset = format_token(tokens, :utc_offset)
124 | 
125 |     timezone_from_zone(zone, naive_datetime, opts) ||
126 |       timezone_from_offset(offset, naive_datetime, opts) ||
127 |       naive_datetime
128 |   end
129 | 
130 |   defp timezone_from_zone(nil, _naive_datetime, _opts), do: nil
131 | 
132 |   defp timezone_from_zone(abbr, naive_datetime, opts) do
133 |     with %{name: name} <-
134 |            TimezoneAbbreviations.zone_by_abbreviation(
135 |              abbr,
136 |              Keyword.put(opts, :at, naive_datetime)
137 |            ) do
138 |       DateTime.from_naive(naive_datetime, name)
139 |     end
140 |   end
141 | 
142 |   defp timezone_from_offset(nil, _naive_datetime, _opts), do: nil
143 | 
144 |   defp timezone_from_offset(offset, naive_datetime, opts) do
145 |     with %{name: name} <-
146 |            TimezoneAbbreviations.zone_by_offset(offset, Keyword.put(opts, :at, naive_datetime)) do
147 |       DateTime.from_naive(naive_datetime, name)
148 |     end
149 |   end
150 | 
151 |   defp to_datetime(_opts, %DateTime{} = datetime, _tokens), do: {:ok, datetime}
152 | 
153 |   defp to_datetime(opts, %NaiveDateTime{} = ndt, tokens) do
154 |     {:ok, from_naive_datetime_and_tokens(opts, ndt, tokens)}
155 |   end
156 | 
157 |   defp to_datetime(_opts, _error, _tokens), do: :error
158 | end
159 | 


--------------------------------------------------------------------------------
/.credo.exs:
--------------------------------------------------------------------------------
  1 | # This file contains the configuration for Credo and you are probably reading
  2 | # this after creating it with `mix credo.gen.config`.
  3 | #
  4 | # If you find anything wrong or unclear in this file, please report an
  5 | # issue on GitHub: https://github.com/rrrene/credo/issues
  6 | #
  7 | %{
  8 |   #
  9 |   # You can have as many configs as you like in the `configs:` field.
 10 |   configs: [
 11 |     %{
 12 |       #
 13 |       # Run any exec using `mix credo -C <name>`. If no exec name is given
 14 |       # "default" is used.
 15 |       #
 16 |       name: "default",
 17 |       #
 18 |       # These are the files included in the analysis:
 19 |       files: %{
 20 |         #
 21 |         # You can give explicit globs or simply directories.
 22 |         # In the latter case `**/*.{ex,exs}` will be used.
 23 |         #
 24 |         included: ["lib/", "src/", "test/", "web/", "apps/"],
 25 |         excluded: [~r"/_build/", ~r"/deps/", ~r"/node_modules/"]
 26 |       },
 27 |       #
 28 |       # Load and configure plugins here:
 29 |       #
 30 |       plugins: [],
 31 |       #
 32 |       # If you create your own checks, you must specify the source files for
 33 |       # them here, so they can be loaded by Credo before running the analysis.
 34 |       #
 35 |       requires: [],
 36 |       #
 37 |       # If you want to enforce a style guide and need a more traditional linting
 38 |       # experience, you can change `strict` to `true` below:
 39 |       #
 40 |       strict: false,
 41 |       #
 42 |       # If you want to use uncolored output by default, you can change `color`
 43 |       # to `false` below:
 44 |       #
 45 |       color: true,
 46 |       #
 47 |       # You can customize the parameters of any check by adding a second element
 48 |       # to the tuple.
 49 |       #
 50 |       # To disable a check put `false` as second element:
 51 |       #
 52 |       #     {Credo.Check.Design.DuplicatedCode, false}
 53 |       #
 54 |       checks: [
 55 |         #
 56 |         ## Consistency Checks
 57 |         #
 58 |         {Credo.Check.Consistency.ExceptionNames, []},
 59 |         {Credo.Check.Consistency.LineEndings, []},
 60 |         {Credo.Check.Consistency.ParameterPatternMatching, []},
 61 |         {Credo.Check.Consistency.SpaceAroundOperators, []},
 62 |         {Credo.Check.Consistency.SpaceInParentheses, []},
 63 |         {Credo.Check.Consistency.TabsOrSpaces, []},
 64 | 
 65 |         #
 66 |         ## Design Checks
 67 |         #
 68 |         # You can customize the priority of any check
 69 |         # Priority values are: `low, normal, high, higher`
 70 |         #
 71 |         {Credo.Check.Design.AliasUsage,
 72 |          [priority: :low, if_nested_deeper_than: 2, if_called_more_often_than: 0]},
 73 |         # You can also customize the exit_status of each check.
 74 |         # If you don't want TODO comments to cause `mix credo` to fail, just
 75 |         # set this value to 0 (zero).
 76 |         #
 77 |         {Credo.Check.Design.TagTODO, [exit_status: 2]},
 78 |         {Credo.Check.Design.TagFIXME, []},
 79 | 
 80 |         #
 81 |         ## Readability Checks
 82 |         #
 83 |         {Credo.Check.Readability.AliasOrder, []},
 84 |         {Credo.Check.Readability.FunctionNames, []},
 85 |         {Credo.Check.Readability.LargeNumbers, []},
 86 |         {Credo.Check.Readability.MaxLineLength, [priority: :low, max_length: 120]},
 87 |         {Credo.Check.Readability.ModuleAttributeNames, []},
 88 |         {Credo.Check.Readability.ModuleDoc, []},
 89 |         {Credo.Check.Readability.ModuleNames, []},
 90 |         {Credo.Check.Readability.ParenthesesInCondition, []},
 91 |         {Credo.Check.Readability.ParenthesesOnZeroArityDefs, []},
 92 |         {Credo.Check.Readability.PredicateFunctionNames, []},
 93 |         {Credo.Check.Readability.PreferImplicitTry, []},
 94 |         {Credo.Check.Readability.RedundantBlankLines, []},
 95 |         {Credo.Check.Readability.Semicolons, []},
 96 |         {Credo.Check.Readability.SpaceAfterCommas, []},
 97 |         {Credo.Check.Readability.StringSigils, []},
 98 |         {Credo.Check.Readability.TrailingBlankLine, []},
 99 |         {Credo.Check.Readability.TrailingWhiteSpace, []},
100 |         # TODO: enable by default in Credo 1.1
101 |         {Credo.Check.Readability.UnnecessaryAliasExpansion, false},
102 |         {Credo.Check.Readability.VariableNames, []},
103 | 
104 |         #
105 |         ## Refactoring Opportunities
106 |         #
107 |         {Credo.Check.Refactor.CondStatements, []},
108 |         {Credo.Check.Refactor.CyclomaticComplexity, []},
109 |         {Credo.Check.Refactor.FunctionArity, []},
110 |         {Credo.Check.Refactor.LongQuoteBlocks, []},
111 |         {Credo.Check.Refactor.MapInto, false},
112 |         {Credo.Check.Refactor.MatchInCondition, []},
113 |         {Credo.Check.Refactor.NegatedConditionsInUnless, []},
114 |         {Credo.Check.Refactor.NegatedConditionsWithElse, []},
115 |         {Credo.Check.Refactor.Nesting, []},
116 |         {Credo.Check.Refactor.UnlessWithElse, []},
117 |         {Credo.Check.Refactor.WithClauses, []},
118 | 
119 |         #
120 |         ## Warnings
121 |         #
122 |         {Credo.Check.Warning.BoolOperationOnSameValues, []},
123 |         {Credo.Check.Warning.ExpensiveEmptyEnumCheck, []},
124 |         {Credo.Check.Warning.IExPry, []},
125 |         {Credo.Check.Warning.IoInspect, []},
126 |         {Credo.Check.Warning.LazyLogging, false},
127 |         {Credo.Check.Warning.OperationOnSameValues, []},
128 |         {Credo.Check.Warning.OperationWithConstantResult, []},
129 |         {Credo.Check.Warning.RaiseInsideRescue, []},
130 |         {Credo.Check.Warning.UnusedEnumOperation, []},
131 |         {Credo.Check.Warning.UnusedFileOperation, []},
132 |         {Credo.Check.Warning.UnusedKeywordOperation, []},
133 |         {Credo.Check.Warning.UnusedListOperation, []},
134 |         {Credo.Check.Warning.UnusedPathOperation, []},
135 |         {Credo.Check.Warning.UnusedRegexOperation, []},
136 |         {Credo.Check.Warning.UnusedStringOperation, []},
137 |         {Credo.Check.Warning.UnusedTupleOperation, []},
138 | 
139 |         #
140 |         # Controversial and experimental checks (opt-in, just replace `false` with `[]`)
141 |         #
142 |         {Credo.Check.Consistency.MultiAliasImportRequireUse, false},
143 |         {Credo.Check.Design.DuplicatedCode, false},
144 |         {Credo.Check.Readability.MultiAlias, false},
145 |         {Credo.Check.Readability.Specs, false},
146 |         {Credo.Check.Readability.SinglePipe, false},
147 |         {Credo.Check.Refactor.ABCSize, false},
148 |         {Credo.Check.Refactor.AppendSingleItem, false},
149 |         {Credo.Check.Refactor.DoubleBooleanNegation, false},
150 |         {Credo.Check.Refactor.ModuleDependencies, false},
151 |         {Credo.Check.Refactor.PipeChainStart, false},
152 |         {Credo.Check.Refactor.VariableRebinding, false},
153 |         {Credo.Check.Warning.MapGetUnsafePass, false},
154 |         {Credo.Check.Warning.UnsafeToAtom, false}
155 | 
156 |         #
157 |         # Custom checks can be created using `mix credo.gen.check`.
158 |         #
159 |       ]
160 |     }
161 |   ]
162 | }
163 | 


--------------------------------------------------------------------------------
/test/support/macros.ex:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParserTestMacros do
  2 |   @moduledoc false
  3 |   alias DateTimeParser
  4 |   alias DateTimeParserTest.Recorder
  5 |   import ExUnit.Assertions
  6 | 
  7 |   def to_iso(%NaiveDateTime{} = datetime), do: NaiveDateTime.to_iso8601(datetime)
  8 |   def to_iso(%DateTime{} = datetime), do: DateTime.to_iso8601(datetime)
  9 |   def to_iso(%Date{} = date), do: Date.to_iso8601(date)
 10 |   def to_iso(%Time{} = time), do: Time.to_iso8601(time)
 11 |   def to_iso(string) when is_binary(string), do: string
 12 | 
 13 |   def run_test(fun, timestamp, expected, opts) do
 14 |     case apply(DateTimeParser, fun, [timestamp, opts]) do
 15 |       {:ok, result} ->
 16 |         case expected do
 17 |           %{} = expected ->
 18 |             assert result == expected,
 19 |                    "Expected #{inspect(expected)} but returned #{inspect(result)} instead"
 20 | 
 21 |           expected when is_binary(expected) ->
 22 |             assert to_iso(result) == expected,
 23 |                    "Expected #{inspect(expected)} but returned #{inspect(result)} instead"
 24 |         end
 25 | 
 26 |         Recorder.add(
 27 |           timestamp,
 28 |           expected,
 29 |           to_string(fun),
 30 |           opts
 31 |         )
 32 | 
 33 |       error ->
 34 |         flunk("""
 35 |         #{timestamp} should parse to #{expected}
 36 | 
 37 |         Got this instead:
 38 |           #{inspect(error)}
 39 |         """)
 40 |     end
 41 |   end
 42 | 
 43 |   def test_name(fun, timestamp, []), do: "#{fun} timestamp #{timestamp}"
 44 | 
 45 |   def test_name(fun, timestamp, opts),
 46 |     do: "#{fun} timestamp #{timestamp} with opts #{inspect(opts)}"
 47 | 
 48 |   defmacro test_parsing(timestamp, expected, opts \\ []) do
 49 |     quote do
 50 |       test_name =
 51 |         DateTimeParserTestMacros.test_name(
 52 |           :parse,
 53 |           unquote(timestamp),
 54 |           unquote(opts)
 55 |         )
 56 | 
 57 |       test test_name do
 58 |         DateTimeParserTestMacros.run_test(
 59 |           :parse,
 60 |           unquote(timestamp),
 61 |           unquote(expected),
 62 |           unquote(opts)
 63 |         )
 64 |       end
 65 |     end
 66 |   end
 67 | 
 68 |   defmacro test_datetime_parsing(timestamp, expected, opts \\ []) do
 69 |     quote do
 70 |       test_name =
 71 |         DateTimeParserTestMacros.test_name(
 72 |           :parse_datetime,
 73 |           unquote(timestamp),
 74 |           unquote(opts)
 75 |         )
 76 | 
 77 |       test test_name do
 78 |         DateTimeParserTestMacros.run_test(
 79 |           :parse_datetime,
 80 |           unquote(timestamp),
 81 |           unquote(expected),
 82 |           unquote(opts)
 83 |         )
 84 |       end
 85 |     end
 86 |   end
 87 | 
 88 |   defmacro test_time_parsing(timestamp, expected, opts \\ []) do
 89 |     quote do
 90 |       test_name =
 91 |         DateTimeParserTestMacros.test_name(
 92 |           :parse_time,
 93 |           unquote(timestamp),
 94 |           unquote(opts)
 95 |         )
 96 | 
 97 |       test test_name do
 98 |         DateTimeParserTestMacros.run_test(
 99 |           :parse_time,
100 |           unquote(timestamp),
101 |           unquote(expected),
102 |           unquote(opts)
103 |         )
104 |       end
105 |     end
106 |   end
107 | 
108 |   defmacro test_date_parsing(timestamp, expected, opts \\ []) do
109 |     quote do
110 |       test_name =
111 |         DateTimeParserTestMacros.test_name(
112 |           :parse_date,
113 |           unquote(timestamp),
114 |           unquote(opts)
115 |         )
116 | 
117 |       test test_name do
118 |         DateTimeParserTestMacros.run_test(
119 |           :parse_date,
120 |           unquote(timestamp),
121 |           unquote(expected),
122 |           unquote(opts)
123 |         )
124 |       end
125 |     end
126 |   end
127 | 
128 |   def test_error_name(fun, timestamp, []), do: "does not #{fun} timestamp #{timestamp}"
129 | 
130 |   def test_error_name(fun, timestamp, opts),
131 |     do: "does not #{fun} timestamp #{timestamp} with opts #{inspect(opts)}"
132 | 
133 |   def run_error_test(fun, timestamp, expected, opts) do
134 |     case apply(DateTimeParser, fun, [timestamp, opts]) do
135 |       {_ok_or_error, message}
136 |       when expected != message and not is_nil(expected) ->
137 |         flunk("""
138 |         #{timestamp} should not have parsed. Opts #{inspect(opts)}
139 | 
140 |         Expected error:
141 |           #{expected}
142 | 
143 |         Got this instead:
144 |           #{inspect(message)}
145 |         """)
146 | 
147 |       {:error, message} ->
148 |         if expected do
149 |           assert message == expected,
150 |                  "Expected error message #{inspect(expected)} but returned #{inspect(message)} instead"
151 |         end
152 | 
153 |         Recorder.add(
154 |           timestamp,
155 |           message,
156 |           to_string(fun),
157 |           opts
158 |         )
159 |     end
160 |   end
161 | 
162 |   defmacro test_error(timestamp, expected_message \\ nil, opts \\ []) do
163 |     quote do
164 |       test_name =
165 |         DateTimeParserTestMacros.test_error_name(
166 |           :parse,
167 |           unquote(timestamp),
168 |           unquote(opts)
169 |         )
170 | 
171 |       test test_name do
172 |         DateTimeParserTestMacros.run_error_test(
173 |           :parse,
174 |           unquote(timestamp),
175 |           unquote(expected_message),
176 |           unquote(opts)
177 |         )
178 |       end
179 |     end
180 |   end
181 | 
182 |   defmacro test_datetime_error(timestamp, expected_message \\ nil, opts \\ []) do
183 |     quote do
184 |       test_name =
185 |         DateTimeParserTestMacros.test_error_name(
186 |           :parse_datetime,
187 |           unquote(timestamp),
188 |           unquote(opts)
189 |         )
190 | 
191 |       test test_name do
192 |         DateTimeParserTestMacros.run_error_test(
193 |           :parse_datetime,
194 |           unquote(timestamp),
195 |           unquote(expected_message),
196 |           unquote(opts)
197 |         )
198 |       end
199 |     end
200 |   end
201 | 
202 |   defmacro test_date_error(timestamp, expected_message \\ nil, opts \\ []) do
203 |     quote do
204 |       test_name =
205 |         DateTimeParserTestMacros.test_error_name(
206 |           :parse_date,
207 |           unquote(timestamp),
208 |           unquote(opts)
209 |         )
210 | 
211 |       test test_name do
212 |         DateTimeParserTestMacros.run_error_test(
213 |           :parse_date,
214 |           unquote(timestamp),
215 |           unquote(expected_message),
216 |           unquote(opts)
217 |         )
218 |       end
219 |     end
220 |   end
221 | 
222 |   defmacro test_time_error(timestamp, expected_message \\ nil, opts \\ []) do
223 |     quote do
224 |       test_name =
225 |         DateTimeParserTestMacros.test_error_name(
226 |           :parse_time,
227 |           unquote(timestamp),
228 |           unquote(opts)
229 |         )
230 | 
231 |       test test_name do
232 |         DateTimeParserTestMacros.run_error_test(
233 |           :parse_time,
234 |           unquote(timestamp),
235 |           unquote(expected_message),
236 |           unquote(opts)
237 |         )
238 |       end
239 |     end
240 |   end
241 | end
242 | 


--------------------------------------------------------------------------------
/mix.lock:
--------------------------------------------------------------------------------
 1 | %{
 2 |   "benchee": {:hex, :benchee, "1.5.0", "4d812c31d54b0ec0167e91278e7de3f596324a78a096fd3d0bea68bb0c513b10", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}, {:statistex, "~> 1.1", [hex: :statistex, repo: "hexpm", optional: false]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "5b075393aea81b8ae74eadd1c28b1d87e8a63696c649d8293db7c4df3eb67535"},
 3 |   "bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},
 4 |   "certifi": {:hex, :certifi, "2.6.1", "dbab8e5e155a0763eea978c913ca280a6b544bfa115633fa20249c3d396d9493", [:rebar3], [], "hexpm", "524c97b4991b3849dd5c17a631223896272c6b0af446778ba4675a1dff53bb7e"},
 5 |   "combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},
 6 |   "credo": {:hex, :credo, "1.7.13", "126a0697df6b7b71cd18c81bc92335297839a806b6f62b61d417500d1070ff4e", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "47641e6d2bbff1e241e87695b29f617f1a8f912adea34296fb10ecc3d7e9e84f"},
 7 |   "deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
 8 |   "earmark_parser": {:hex, :earmark_parser, "1.4.44", "f20830dd6b5c77afe2b063777ddbbff09f9759396500cdbe7523efd58d7a339c", [:mix], [], "hexpm", "4778ac752b4701a5599215f7030989c989ffdc4f6df457c5f36938cc2d2a2750"},
 9 |   "erlex": {:hex, :erlex, "0.2.6", "c7987d15e899c7a2f34f5420d2a2ea0d659682c06ac607572df55a43753aa12e", [:mix], [], "hexpm", "2ed2e25711feb44d52b17d2780eabf998452f6efda104877a3881c2f8c0c0c75"},
10 |   "ex_doc": {:hex, :ex_doc, "0.39.1", "e19d356a1ba1e8f8cfc79ce1c3f83884b6abfcb79329d435d4bbb3e97ccc286e", [:mix], [{:earmark_parser, "~> 1.4.44", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.0", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14 or ~> 1.0", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1 or ~> 1.0", [hex: :makeup_erlang, repo: "hexpm", optional: false]}, {:makeup_html, ">= 0.1.0", [hex: :makeup_html, repo: "hexpm", optional: true]}], "hexpm", "8abf0ed3e3ca87c0847dfc4168ceab5bedfe881692f1b7c45f4a11b232806865"},
11 |   "exprintf": {:hex, :exprintf, "0.2.1", "b7e895dfb00520cfb7fc1671303b63b37dc3897c59be7cbf1ae62f766a8a0314", [:mix], [], "hexpm", "20a0e8c880be90e56a77fcc82533c5d60c643915c7ce0cc8aa1e06ed6001da28"},
12 |   "exprof": {:hex, :exprof, "0.2.4", "13ddc0575a6d24b52e7c6809d2a46e9ad63a4dd179628698cdbb6c1f6e497c98", [:mix], [{:exprintf, "~> 0.2", [hex: :exprintf, repo: "hexpm", optional: false]}], "hexpm", "0884bcb66afc421c75d749156acbb99034cc7db6d3b116c32e36f32551106957"},
13 |   "file_system": {:hex, :file_system, "1.1.1", "31864f4685b0148f25bd3fbef2b1228457c0c89024ad67f7a81a3ffbc0bbad3a", [:mix], [], "hexpm", "7a15ff97dfe526aeefb090a7a9d3d03aa907e100e262a0f8f7746b78f8f87a5d"},
14 |   "hackney": {:hex, :hackney, "1.17.4", "99da4674592504d3fb0cfef0db84c3ba02b4508bae2dff8c0108baa0d6e0977c", [:rebar3], [{:certifi, "~>2.6.1", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "~>6.1.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "~>1.0.0", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~>1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:parse_trans, "3.3.1", [hex: :parse_trans, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~>1.1.0", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}, {:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "de16ff4996556c8548d512f4dbe22dd58a587bf3332e7fd362430a7ef3986b16"},
15 |   "idna": {:hex, :idna, "6.1.1", "8a63070e9f7d0c62eb9d9fcb360a7de382448200fbbd1b106cc96d3d8099df8d", [:rebar3], [{:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "92376eb7894412ed19ac475e4a86f7b413c1b9fbb5bd16dccd57934157944cea"},
16 |   "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"},
17 |   "kday": {:hex, :kday, "1.1.0", "64efac85279a12283eaaf3ad6f13001ca2dff943eda8c53288179775a8c057a0", [:mix], [{:ex_doc, "~> 0.21", [hex: :ex_doc, repo: "hexpm", optional: true]}], "hexpm", "69703055d63b8d5b260479266c78b0b3e66f7aecdd2022906cd9bf09892a266d"},
18 |   "makeup": {:hex, :makeup, "1.2.1", "e90ac1c65589ef354378def3ba19d401e739ee7ee06fb47f94c687016e3713d1", [:mix], [{:nimble_parsec, "~> 1.4", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "d36484867b0bae0fea568d10131197a4c2e47056a6fbe84922bf6ba71c8d17ce"},
19 |   "makeup_elixir": {:hex, :makeup_elixir, "1.0.1", "e928a4f984e795e41e3abd27bfc09f51db16ab8ba1aebdba2b3a575437efafc2", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "7284900d412a3e5cfd97fdaed4f5ed389b8f2b4cb49efc0eb3bd10e2febf9507"},
20 |   "makeup_erlang": {:hex, :makeup_erlang, "1.0.2", "03e1804074b3aa64d5fad7aa64601ed0fb395337b982d9bcf04029d68d51b6a7", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "af33ff7ef368d5893e4a267933e7744e46ce3cf1f61e2dccf53a111ed3aa3727"},
21 |   "metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm", "69b09adddc4f74a40716ae54d140f93beb0fb8978d8636eaded0c31b6f099f16"},
22 |   "mimerl": {:hex, :mimerl, "1.2.0", "67e2d3f571088d5cfd3e550c383094b47159f3eee8ffa08e64106cdf5e981be3", [:rebar3], [], "hexpm", "f278585650aa581986264638ebf698f8bb19df297f66ad91b18910dfc6e19323"},
23 |   "nimble_parsec": {:hex, :nimble_parsec, "1.4.2", "8efba0122db06df95bfaa78f791344a89352ba04baedd3849593bfce4d0dc1c6", [:mix], [], "hexpm", "4b21398942dda052b403bbe1da991ccd03a053668d147d53fb8c4e0efe09c973"},
24 |   "parse_trans": {:hex, :parse_trans, "3.3.1", "16328ab840cc09919bd10dab29e431da3af9e9e7e7e6f0089dd5a2d2820011d8", [:rebar3], [], "hexpm", "07cd9577885f56362d414e8c4c4e6bdf10d43a8767abb92d24cbe8b24c54888b"},
25 |   "ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.6", "cf344f5692c82d2cd7554f5ec8fd961548d4fd09e7d22f5b62482e5aeaebd4b0", [:make, :mix, :rebar3], [], "hexpm", "bdb0d2471f453c88ff3908e7686f86f9be327d065cc1ec16fa4540197ea04680"},
26 |   "statistex": {:hex, :statistex, "1.1.0", "7fec1eb2f580a0d2c1a05ed27396a084ab064a40cfc84246dbfb0c72a5c761e5", [:mix], [], "hexpm", "f5950ea26ad43246ba2cce54324ac394a4e7408fdcf98b8e230f503a0cba9cf5"},
27 |   "tz": {:hex, :tz, "0.28.1", "717f5ffddfd1e475e2a233e221dc0b4b76c35c4b3650b060c8e3ba29dd6632e9", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:mint, "~> 1.6", [hex: :mint, repo: "hexpm", optional: true]}], "hexpm", "bfdca1aa1902643c6c43b77c1fb0cb3d744fd2f09a8a98405468afdee0848c8a"},
28 |   "tzdata": {:hex, :tzdata, "1.1.0", "72f5babaa9390d0f131465c8702fa76da0919e37ba32baa90d93c583301a8359", [:mix], [{:hackney, "~> 1.17", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "18f453739b48d3dc5bcf0e8906d2dc112bb40baafe2c707596d89f3c8dd14034"},
29 |   "unicode_util_compat": {:hex, :unicode_util_compat, "0.7.0", "bc84380c9ab48177092f43ac89e4dfa2c6d62b40b8bd132b1059ecc7232f9a78", [:rebar3], [], "hexpm", "25eee6d67df61960cf6a794239566599b09e17e668d3700247bc498638152521"},
30 | }
31 | 


--------------------------------------------------------------------------------
/lib/date_time_parser.ex:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParser do
  2 |   docs = "README.md" |> File.read!() |> String.split("<!-- MDOC -->") |> Enum.fetch!(1)
  3 |   docs = if elem(:os.type(), 0) == :win32, do: String.replace(docs, "\r\n", "\n"), else: docs
  4 |   @moduledoc docs
  5 |   @external_resource "README.md"
  6 | 
  7 |   import DateTimeParser.Formatters
  8 |   alias DateTimeParser.Parser
  9 | 
 10 |   @type assume_date :: {:assume_date, boolean() | Date.t()}
 11 |   @type assume_time :: {:assume_time, boolean() | Time.t()}
 12 |   @type assume_utc :: {:assume_utc, boolean()}
 13 |   @type assume_tz_abbreviations :: {:assume_utc, map()}
 14 |   @type assume_tz_offsets :: {:assume_utc, map()}
 15 |   @type use_1904_date_system :: {:use_1904_date_system, boolean()}
 16 |   @type to_utc :: {:to_utc, boolean()}
 17 | 
 18 |   @typedoc "List of modules that implement the `DateTimeParser.Parser` behaviour."
 19 |   @type parsers :: {:parsers, list(atom())}
 20 | 
 21 |   @typedoc """
 22 |   Options for `parse_datetime/2`
 23 | 
 24 |   * `:assume_utc` Default `false`.
 25 |   Only applicable for strings where parsing could not determine a timezone. Instead of returning a
 26 |   NaiveDateTime, this option will assume them to be in UTC timezone, and therefore return a
 27 |   DateTime. If the timezone is determined, then it will continue to be returned in the original
 28 |   timezone. See `to_utc` option to also convert it to UTC.
 29 | 
 30 |   * `:to_utc` Default `false`.
 31 |   If there's a timezone detected in the string, then attempt to convert to UTC timezone. If you
 32 |   know that your timestamps are in the future and are going to store it for later use, it may be
 33 |   better to convert to UTC and keep the original timestamp since government organizations may change
 34 |   timezone rules before the timestamp elapses, therefore making the UTC timestamp wrong or invalid.
 35 |   [Check out the guide on future timestamps](./future-utc-datetime.html).
 36 | 
 37 |   * `:assume_time` Default `false`.
 38 |   If a time cannot be determined, then it will not be assumed by default. If you supply `true`, then
 39 |   `~T[00:00:00]` will be assumed. You can also supply your own time, and the found tokens will be
 40 |   merged with it.
 41 | 
 42 |   * `:use_1904_date_system` Default `false`.
 43 |   For Serial timestamps, the parser will use the 1900 Date System by default. If you supply `true`, then
 44 |   the 1904 Date System will be used to parse the timestamp.
 45 | 
 46 |   * `:assume_tz_offsets`.
 47 |   Timezones may be expressed as time offsets, eg "-0400" to represent 4 hours before GMT. The default
 48 |   assumption for these offsets is to map them directly to "Etc/GMT-4" when possible. However, you may
 49 |   provide your own assumptions. To see the default offets, see
 50 |   `DateTimeParser.TimezoneAbbreviations.default_offsets`.
 51 | 
 52 |   * `:assume_tz_abbreviations`.
 53 |   Timezones may be expressed as timezone abbreviations, eg "EST" can represent Eastern Standard Time.
 54 |   The default assumptions for these abbreviations is to map them to the most likely timezone. However,
 55 |   you may prefer a different set of timezone assumptions, eg: "CST" means US Central Standard Time by
 56 |   default, but you may want it to mean China Standard Time; you would provide: `%{"CST" => "Asia/Shanghai"}`
 57 |   To see the default abbreviations, see `DateTimeParser.TimezoneAbbreviations.default_abbreviations`.
 58 | 
 59 |   * `:parsers` The parsers to use when analyzing the string. When `Parser.Tokenizer`, the appropriate tokenizer
 60 |   will be used depending on the function used and conditions found in the string. **Order matters**
 61 |   and determines the order in which parsers are attempted. These are the available built-in parsers:
 62 |   #{for parser <- DateTimeParser.Parser.builtin_parsers(), do: "  * `#{inspect(parser)}`\n"}
 63 |     This is the default in this order:
 64 |   #{for parser <- DateTimeParser.Parser.default_parsers(), do: "  1. `#{inspect(parser)}`\n"}
 65 |   """
 66 |   @type parse_datetime_options :: [
 67 |           assume_utc()
 68 |           | to_utc()
 69 |           | assume_time()
 70 |           | use_1904_date_system()
 71 |           | parsers()
 72 |           | assume_tz_offsets()
 73 |           | assume_tz_abbreviations()
 74 |         ]
 75 | 
 76 |   @typedoc """
 77 |   Options for `parse_date/2`
 78 | 
 79 |   * `:assume_date` Default `false`.
 80 |   If a date cannot be fully determined, then it will not be assumed by default. If you supply
 81 |   `true`, then `Date.utc_today()` will be assumed. You can also supply your own date, and the found
 82 |   tokens will be merged with it.
 83 |   """
 84 |   @type parse_date_options :: [assume_date() | parsers()]
 85 | 
 86 |   @typedoc """
 87 |   Options for `parse_time/2`.
 88 | 
 89 |   See `t:parse_datetime_options/0` for further definition.
 90 |   """
 91 |   @type parse_time_options :: [parsers()]
 92 | 
 93 |   @typedoc """
 94 |   Options for `parse/2`.
 95 | 
 96 |   Combination of `t:parse_date_options/0` and `t:parse_datetime_options/0` and
 97 |   `t:parse_time_options/0`
 98 |   """
 99 |   @type parse_options :: parse_datetime_options() | parse_date_options() | parse_time_options()
100 | 
101 |   @doc """
102 |   Parse a `%DateTime{}`, `%NaiveDateTime{}`, `%Date{}`, or `%Time{}` from a string.
103 | 
104 |   Accepts `t:parse_options/0`
105 |   """
106 |   @spec parse(String.t() | nil, parse_options()) ::
107 |           {:ok, DateTime.t() | NaiveDateTime.t() | Date.t() | Time.t()} | {:error, String.t()}
108 |   def parse(string, opts \\ [])
109 | 
110 |   def parse(string, opts) when is_binary(string) do
111 |     opts = Keyword.put(opts, :context, :best)
112 | 
113 |     with {:error, _} <- parse_datetime(string, opts),
114 |          {:error, _} <- parse_date(string, opts) do
115 |       parse_time(string, opts)
116 |     end
117 |   end
118 | 
119 |   def parse(value, _opts), do: {:error, "Could not parse #{inspect(value)}"}
120 | 
121 |   @doc """
122 |   Parse a `%DateTime{}`, `%NaiveDateTime{}`, `%Date{}`, or `%Time{}` from a string. Raises a
123 |   `DateTimeParser.ParseError` when parsing fails.
124 | 
125 |   Accepts `t:parse_options/0`.
126 |   """
127 |   @spec parse!(String.t() | nil, parse_options()) ::
128 |           DateTime.t() | NaiveDateTime.t() | Date.t() | Time.t() | no_return()
129 |   def parse!(string, opts \\ []) do
130 |     case parse(string, opts) do
131 |       {:ok, result} -> result
132 |       {:error, message} -> raise(__MODULE__.ParseError, message)
133 |     end
134 |   end
135 | 
136 |   @doc """
137 |   Parse a `%DateTime{}` or `%NaiveDateTime{}` from a string.
138 | 
139 |   Accepts options `t:parse_datetime_options/0`
140 |   """
141 |   @spec parse_datetime(String.t() | nil, parse_datetime_options()) ::
142 |           {:ok, DateTime.t() | NaiveDateTime.t()} | {:error, String.t()}
143 |   def parse_datetime(string, opts \\ [])
144 | 
145 |   def parse_datetime(string, opts) when is_binary(string) do
146 |     with {:ok, parser} <- string |> clean() |> Parser.build(:datetime, opts),
147 |          {:ok, datetime} <- parser.mod.parse(parser) do
148 |       {:ok, datetime}
149 |     else
150 |       _ ->
151 |         {:error, "Could not parse #{inspect(string)}"}
152 |     end
153 |   end
154 | 
155 |   def parse_datetime(value, _opts), do: {:error, "Could not parse #{inspect(value)}"}
156 | 
157 |   @doc """
158 |   Parse a `%DateTime{}` or `%NaiveDateTime{}` from a string. Raises a `DateTimeParser.ParseError` when
159 |   parsing fails.
160 | 
161 |   Accepts options `t:parse_datetime_options/0`.
162 |   """
163 |   @spec parse_datetime!(String.t() | nil, parse_datetime_options()) ::
164 |           DateTime.t() | NaiveDateTime.t() | no_return()
165 |   def parse_datetime!(string, opts \\ []) do
166 |     case parse_datetime(string, opts) do
167 |       {:ok, result} -> result
168 |       {:error, message} -> raise(__MODULE__.ParseError, message)
169 |     end
170 |   end
171 | 
172 |   @doc """
173 |   Parse `%Time{}` from a string. Accepts options `t:parse_time_options/0`
174 |   """
175 |   @spec parse_time(String.t() | nil, parse_time_options()) ::
176 |           {:ok, Time.t()} | {:error, String.t()}
177 |   def parse_time(string, opts \\ [])
178 | 
179 |   def parse_time(string, opts) when is_binary(string) do
180 |     with {:ok, parser} <- string |> clean() |> Parser.build(:time, opts),
181 |          {:ok, time} <- parser.mod.parse(parser) do
182 |       {:ok, time}
183 |     else
184 |       _ ->
185 |         {:error, "Could not parse #{inspect(string)}"}
186 |     end
187 |   end
188 | 
189 |   def parse_time(value, _opts), do: {:error, "Could not parse #{inspect(value)}"}
190 | 
191 |   @doc """
192 |   Parse `%Time{}` from a string. Raises a `DateTimeParser.ParseError` when parsing fails.
193 |   """
194 |   @spec parse_time!(String.t() | nil, parse_time_options()) :: Time.t() | no_return()
195 |   def parse_time!(string, opts \\ []) do
196 |     case parse_time(string, opts) do
197 |       {:ok, result} -> result
198 |       {:error, message} -> raise(__MODULE__.ParseError, message)
199 |     end
200 |   end
201 | 
202 |   @doc """
203 |   Parse `%Date{}` from a string.
204 | 
205 |   Accepts options `t:parse_date_options/0`
206 |   """
207 |   @spec parse_date(String.t() | nil, parse_date_options()) ::
208 |           {:ok, Date.t()} | {:error, String.t()}
209 |   def parse_date(string, opts \\ [])
210 | 
211 |   def parse_date(string, opts) when is_binary(string) do
212 |     with {:ok, parser} <- string |> clean() |> Parser.build(:date, opts),
213 |          {:ok, date} <- parser.mod.parse(parser) do
214 |       {:ok, date}
215 |     else
216 |       _ ->
217 |         {:error, "Could not parse #{inspect(string)}"}
218 |     end
219 |   end
220 | 
221 |   def parse_date(value, _opts), do: {:error, "Could not parse #{inspect(value)}"}
222 | 
223 |   @doc """
224 |   Parse a `%Date{}` from a string. Raises a `DateTimeParser.ParseError` when parsing fails.
225 | 
226 |   Accepts options `t:parse_date_options/0`.
227 |   """
228 |   @spec parse_date!(String.t() | nil, parse_datetime_options()) ::
229 |           Date.t() | no_return()
230 |   def parse_date!(string, opts \\ []) do
231 |     case parse_date(string, opts) do
232 |       {:ok, result} -> result
233 |       {:error, message} -> raise(__MODULE__.ParseError, message)
234 |     end
235 |   end
236 | end
237 | 


--------------------------------------------------------------------------------
/lib/combinators.ex.exs:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParser.Combinators do
  2 |   @moduledoc false
  3 |   # credo:disable-for-this-file
  4 | 
  5 |   @months_map %{
  6 |     "january" => 1,
  7 |     "february" => 2,
  8 |     "march" => 3,
  9 |     "april" => 4,
 10 |     "may" => 5,
 11 |     "june" => 6,
 12 |     "july" => 7,
 13 |     "august" => 8,
 14 |     "september" => 9,
 15 |     "october" => 10,
 16 |     "november" => 11,
 17 |     "december" => 12,
 18 |     "jan" => 1,
 19 |     "feb" => 2,
 20 |     "mar" => 3,
 21 |     "apr" => 4,
 22 |     "jun" => 6,
 23 |     "jul" => 7,
 24 |     "aug" => 8,
 25 |     "sept" => 9,
 26 |     "sep" => 9,
 27 |     "oct" => 10,
 28 |     "nov" => 11,
 29 |     "dec" => 12
 30 |   }
 31 | 
 32 |   def to_integer(value) when is_binary(value), do: String.to_integer(value)
 33 |   def vocal_month_to_numeric_month(value), do: Map.get(@months_map, value)
 34 | 
 35 |   # parsec:DateTimeParser.Combinators
 36 |   import NimbleParsec
 37 | 
 38 |   ### TIMEZONE
 39 |   @time_separator ":"
 40 |   @utc ~w[utc gmt zulu z]
 41 |   @timezone_abbreviations DateTimeParser.TimezoneAbbreviations.all_abbreviations()
 42 |                           |> Enum.map(&String.downcase/1)
 43 |                           |> Enum.sort_by(&{byte_size(&1), &1}, :desc)
 44 | 
 45 |   time_separator = string(@time_separator)
 46 | 
 47 |   offset =
 48 |     ["+", "-"]
 49 |     |> Enum.map(&string/1)
 50 |     |> choice()
 51 |     |> concat([?0..?9] |> ascii_char() |> times(min: 1, max: 2))
 52 |     |> lookahead_not(ascii_char([?/]))
 53 |     |> concat(time_separator |> optional() |> ignore())
 54 |     |> concat([?0..?9] |> ascii_char() |> times(2) |> optional())
 55 |     |> tag(:utc_offset)
 56 |     |> label("offset with +/- and 4 digits")
 57 | 
 58 |   utc =
 59 |     @utc
 60 |     |> Enum.map(&string/1)
 61 |     |> choice()
 62 |     |> eos()
 63 |     |> replace("UTC")
 64 |     |> unwrap_and_tag(:zone_abbr)
 65 |     |> label("timezone with offset")
 66 | 
 67 |   utc_plus_offset = concat(utc, offset)
 68 | 
 69 |   timezone_abbreviation =
 70 |     @timezone_abbreviations
 71 |     |> Enum.map(&string/1)
 72 |     |> choice()
 73 |     |> unwrap_and_tag(:zone_abbr)
 74 |     |> label("timezone abbreviation")
 75 | 
 76 |   second_letter_of_timezone_abbreviation =
 77 |     @timezone_abbreviations
 78 |     |> Enum.map(fn abbr -> abbr |> String.codepoints() |> Enum.at(1) end)
 79 |     |> Enum.reject(&is_nil/1)
 80 |     |> Enum.uniq()
 81 |     |> Enum.map(fn char ->
 82 |       <<codepoint::utf8>> = char
 83 |       codepoint
 84 |     end)
 85 |     |> ascii_char()
 86 | 
 87 |   timezone =
 88 |     choice([
 89 |       utc_plus_offset,
 90 |       utc,
 91 |       offset,
 92 |       timezone_abbreviation
 93 |     ])
 94 | 
 95 |   ## TIME
 96 | 
 97 |   @hour_num ~w(00 01 02 03 04 05 06 07 08 09) ++ Enum.map(23..0//-1, &to_string/1)
 98 |   @second_minute_num ~w(00 01 02 03 04 05 06 07 08 09) ++ Enum.map(59..0//-1, &to_string/1)
 99 |   @am_pm ~w(am a.m a.m. a_m pm p.m p.m. p_m a p)
100 | 
101 |   invalid_time_first_digit = ascii_char([?6..?9])
102 |   space_separator = string(" ")
103 | 
104 |   hour =
105 |     @hour_num
106 |     |> Enum.map(&string/1)
107 |     |> choice()
108 |     |> lookahead_not(invalid_time_first_digit)
109 |     |> map(:to_integer)
110 |     |> unwrap_and_tag(:hour)
111 |     |> label("numeric hour from 00-23")
112 | 
113 |   microsecond =
114 |     [?0..?9]
115 |     |> ascii_char()
116 |     |> times(min: 1, max: 24)
117 |     |> tag(:microsecond)
118 |     |> label("numeric subsecond up to 24 digits")
119 | 
120 |   second_or_minute =
121 |     @second_minute_num
122 |     |> Enum.map(&string/1)
123 |     |> choice()
124 |     |> lookahead_not(invalid_time_first_digit)
125 |     |> map(:to_integer)
126 | 
127 |   second =
128 |     second_or_minute
129 |     |> unwrap_and_tag(:second)
130 |     |> label("numeric second from 00-59")
131 |     |> concat("." |> string() |> ignore() |> optional())
132 |     |> concat(microsecond |> optional())
133 | 
134 |   minute =
135 |     second_or_minute
136 |     |> unwrap_and_tag(:minute)
137 |     |> label("numeric minute from 00-59")
138 | 
139 |   hour_minute =
140 |     hour
141 |     |> concat(time_separator |> ignore())
142 |     |> concat(minute)
143 | 
144 |   hour_minute_second =
145 |     hour_minute
146 |     |> concat(time_separator |> ignore())
147 |     |> concat(second)
148 | 
149 |   am_pm =
150 |     @am_pm
151 |     |> Enum.map(&string/1)
152 |     |> choice()
153 |     |> lookahead_not(second_letter_of_timezone_abbreviation)
154 |     |> unwrap_and_tag(:am_pm)
155 |     |> label("am or pm")
156 | 
157 |   time =
158 |     choice([
159 |       hour_minute_second,
160 |       hour_minute |> lookahead_not(time_separator)
161 |     ])
162 |     |> concat(space_separator |> optional() |> ignore())
163 |     |> concat(am_pm |> optional())
164 | 
165 |   defparsec(:parse_time, time, inline: true)
166 | 
167 |   ## DATE
168 | 
169 |   @days_map %{
170 |     "sun" => "Sunday",
171 |     "mon" => "Monday",
172 |     "tues" => "Tuesday",
173 |     "tue" => "Tuesday",
174 |     "wed" => "Wednesday",
175 |     "weds" => "Wednesday",
176 |     "thurs" => "Thursday",
177 |     "thur" => "Thursday",
178 |     "thu" => "Thursday",
179 |     "fri" => "Friday",
180 |     "sat" => "Saturday"
181 |   }
182 | 
183 |   @vocal_days_long @days_map
184 |                    |> Map.values()
185 |                    |> Enum.uniq()
186 |                    |> Enum.map(&String.downcase/1)
187 |                    |> Enum.sort_by(&byte_size/1)
188 |                    |> Enum.reverse()
189 |                    |> Enum.map(&string/1)
190 | 
191 |   @vocal_days_short @days_map
192 |                     |> Map.keys()
193 |                     |> Enum.uniq()
194 |                     |> Enum.map(&String.downcase/1)
195 |                     |> Enum.sort_by(&byte_size/1)
196 |                     |> Enum.reverse()
197 |                     |> Enum.map(&string/1)
198 |   @date_separator [",", ".", "/", "-", " "]
199 | 
200 |   year4 =
201 |     [?0..?9]
202 |     |> ascii_char()
203 |     |> times(4)
204 |     |> tag(:year)
205 |     |> label("4 digit year")
206 | 
207 |   year =
208 |     [?0..?9]
209 |     |> ascii_char()
210 |     |> times(max: 4, min: 2)
211 |     |> tag(:year)
212 |     |> label("2 or 4 digit year")
213 | 
214 |   vocal_month =
215 |     @months_map
216 |     |> Map.keys()
217 |     |> Enum.sort_by(&byte_size/1)
218 |     |> Enum.reverse()
219 |     |> Enum.map(&string/1)
220 |     |> choice()
221 |     |> concat(string(".") |> optional() |> ignore())
222 |     |> map(:vocal_month_to_numeric_month)
223 |     |> unwrap_and_tag(:month)
224 |     |> label("word month either fully spelled or 3-letter abbreviation")
225 | 
226 |   numeric_month2 =
227 |     ~w(01 02 03 04 05 06 07 08 09 10 11 12)
228 |     |> Enum.map(&string/1)
229 |     |> choice()
230 | 
231 |   numeric_month1 =
232 |     1..9
233 |     |> Enum.map(&to_string/1)
234 |     |> Enum.map(&string/1)
235 |     |> choice()
236 |     |> lookahead_not(integer(1))
237 | 
238 |   numeric_month =
239 |     choice([numeric_month2, numeric_month1])
240 |     |> map(:to_integer)
241 |     |> unwrap_and_tag(:month)
242 |     |> label("numeric month from 01-12")
243 | 
244 |   ordinal_suffix =
245 |     ~w(st nd rd th)
246 |     |> Enum.map(&string/1)
247 |     |> choice()
248 |     |> ignore()
249 |     |> label("ordinal suffix (st, nd, rd, th)")
250 | 
251 |   day2 =
252 |     (~w(01 02 03 04 05 06 07 08 09) ++ Enum.map(10..31, &to_string/1))
253 |     |> Enum.map(&string/1)
254 |     |> choice()
255 | 
256 |   day1 =
257 |     1..9
258 |     |> Enum.map(&to_string/1)
259 |     |> Enum.map(&string/1)
260 |     |> choice()
261 |     |> lookahead_not(integer(1))
262 | 
263 |   day =
264 |     choice([day2, day1])
265 |     |> concat(ordinal_suffix |> optional())
266 |     |> map(:to_integer)
267 |     |> unwrap_and_tag(:day)
268 |     |> label("numeric day from 01-31")
269 | 
270 |   date_separator =
271 |     @date_separator
272 |     |> Enum.map(&string/1)
273 |     |> choice()
274 |     |> ignore()
275 |     |> label("date separator")
276 | 
277 |   month = choice([numeric_month, vocal_month])
278 | 
279 |   month_day =
280 |     month
281 |     |> concat(date_separator |> optional())
282 |     |> concat(day)
283 | 
284 |   month_year =
285 |     month
286 |     |> concat(choice([string(" "), string(", ")]) |> ignore() |> optional())
287 |     |> concat(year4)
288 | 
289 |   day_month =
290 |     day
291 |     |> concat(date_separator |> optional())
292 |     |> concat(month)
293 | 
294 |   day_long_month_year =
295 |     day
296 |     |> concat(date_separator |> optional())
297 |     |> concat(vocal_month)
298 |     |> concat(date_separator |> optional())
299 |     |> concat(year)
300 | 
301 |   year4_month_day =
302 |     year4
303 |     |> concat(date_separator |> optional())
304 |     |> concat(month_day)
305 | 
306 |   year_month_day =
307 |     year
308 |     |> concat(date_separator |> optional())
309 |     |> concat(month_day)
310 | 
311 |   month_day_year =
312 |     month_day
313 |     |> concat(date_separator |> optional())
314 |     |> concat(year)
315 | 
316 |   day_month_year4 =
317 |     day_month
318 |     |> concat(date_separator)
319 |     |> concat(year4)
320 | 
321 |   day_month_year =
322 |     day_month
323 |     |> concat(date_separator |> optional())
324 |     |> concat(year)
325 | 
326 |   formal_date =
327 |     choice([
328 |       day_long_month_year,
329 |       day_month_year4,
330 |       year_month_day,
331 |       day_month_year,
332 |       month_year,
333 |       month_day_year,
334 |       month_day,
335 |       day_month
336 |     ])
337 | 
338 |   us_date =
339 |     choice([
340 |       day_long_month_year,
341 |       year4_month_day,
342 |       month_day_year,
343 |       day_month_year,
344 |       month_year,
345 |       year_month_day,
346 |       month_day,
347 |       day_month
348 |     ])
349 | 
350 |   vocal_day =
351 |     (@vocal_days_long ++ @vocal_days_short)
352 |     |> choice()
353 |     |> unwrap_and_tag(:vocal_day)
354 |     |> label("vocal day spelled out")
355 |     |> concat(space_separator |> optional() |> ignore())
356 | 
357 |   defparsec(
358 |     :parse_date,
359 |     vocal_day
360 |     |> optional()
361 |     |> concat(formal_date)
362 |   )
363 | 
364 |   defparsec(
365 |     :parse_date_us,
366 |     vocal_day
367 |     |> optional()
368 |     |> concat(us_date)
369 |   )
370 | 
371 |   ## DATETIME
372 | 
373 |   @datetime_separator ~w[t - +] ++ [" "]
374 | 
375 |   datetime_separator =
376 |     @datetime_separator
377 |     |> Enum.map(&string/1)
378 |     |> choice()
379 | 
380 |   vocal_month_day_time_year =
381 |     vocal_month
382 |     |> concat(space_separator |> ignore())
383 |     |> concat(day)
384 |     |> concat(space_separator |> ignore())
385 |     |> concat(time)
386 |     |> concat(space_separator |> optional() |> ignore())
387 |     |> concat(year4)
388 | 
389 |   formal_date_time =
390 |     formal_date
391 |     |> concat(datetime_separator |> optional() |> ignore())
392 |     |> concat(time |> optional())
393 |     |> concat(space_separator |> optional() |> ignore())
394 |     |> concat(timezone |> optional())
395 | 
396 |   us_date_time =
397 |     us_date
398 |     |> concat(datetime_separator |> optional() |> ignore())
399 |     |> concat(time)
400 |     |> concat(space_separator |> optional() |> ignore())
401 |     |> concat(timezone |> optional())
402 | 
403 |   defparsec(
404 |     :parse_datetime,
405 |     vocal_day
406 |     |> optional()
407 |     |> choice([
408 |       vocal_month_day_time_year,
409 |       formal_date_time,
410 |       formal_date
411 |     ]),
412 |     export_combinator: true
413 |   )
414 | 
415 |   defparsec(
416 |     :parse_datetime_us,
417 |     vocal_day
418 |     |> optional()
419 |     |> choice([
420 |       vocal_month_day_time_year,
421 |       us_date_time,
422 |       us_date
423 |     ]),
424 |     export_combinator: true
425 |   )
426 | 
427 |   # parsec:DateTimeParser.Combinators
428 | end
429 | 


--------------------------------------------------------------------------------
/lib/date_time_parser/timezone_parser.ex:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParser.TimezoneParser do
  2 |   @moduledoc false
  3 |   @sources [
  4 |     "priv/tzdata2022g/africa",
  5 |     "priv/tzdata2022g/antarctica",
  6 |     "priv/tzdata2022g/asia",
  7 |     "priv/tzdata2022g/australasia",
  8 |     "priv/tzdata2022g/etcetera",
  9 |     "priv/tzdata2022g/europe",
 10 |     "priv/tzdata2022g/northamerica",
 11 |     "priv/tzdata2022g/southamerica",
 12 |     "priv/tzdata2022g/backward"
 13 |   ]
 14 |   for source <- @sources, do: @external_resource(source)
 15 | 
 16 |   defmodule Zone do
 17 |     @moduledoc false
 18 |     defstruct [
 19 |       :name,
 20 |       :utc_offset_sec,
 21 |       :utc_offset_hrs,
 22 |       :from,
 23 |       :until,
 24 |       abbreviations: [],
 25 |       aliases: []
 26 |     ]
 27 |   end
 28 | 
 29 |   defmodule Rule do
 30 |     @moduledoc false
 31 |     defstruct [:name, :from, :until, :save, :letter]
 32 |   end
 33 | 
 34 |   defimpl Inspect, for: Zone do
 35 |     import Inspect.Algebra
 36 | 
 37 |     def inspect(zone, _opts) do
 38 |       concat(["#<TimeZone ", zone.name, " (", zone.utc_offset_hrs, ")", ">"])
 39 |     end
 40 |   end
 41 | 
 42 |   defimpl Inspect, for: Rule do
 43 |     import Inspect.Algebra
 44 | 
 45 |     def inspect(rule, opts) do
 46 |       concat([
 47 |         "#<TimeZoneRule ",
 48 |         rule.name,
 49 |         " ",
 50 |         to_doc(rule.from, opts),
 51 |         " - ",
 52 |         to_doc(rule.until, opts),
 53 |         " ",
 54 |         to_doc(rule.save, opts),
 55 |         ">"
 56 |       ])
 57 |     end
 58 |   end
 59 | 
 60 |   def parse(spec \\ read_file()) do
 61 |     zones = :ets.new(:zones, [:bag])
 62 |     rules = :ets.new(:rules, [:bag])
 63 |     parse(String.split(spec, "\n"), %{zones: zones, rules: rules})
 64 |   end
 65 | 
 66 |   def parse([], meta) do
 67 |     spec = [{{:_, :"$1"}, [], [:"$1"]}]
 68 |     {:ets.select(meta[:zones], spec), :ets.select(meta[:rules], spec)}
 69 |   end
 70 | 
 71 |   def parse([empty | rest], meta) when empty in ["#", nil, "", "\n"],
 72 |     do: parse(rest, meta)
 73 | 
 74 |   def parse(["#" <> _line | rest], meta),
 75 |     do: parse(rest, meta)
 76 | 
 77 |   def parse(["\n" | rest], meta),
 78 |     do: parse(rest, meta)
 79 | 
 80 |   def parse(["" | rest], meta),
 81 |     do: parse(rest, meta)
 82 | 
 83 |   @min ~N[0000-01-01T00:00:00]
 84 |   @max ~N[9999-12-31T23:59:59]
 85 |   def parse(["Zone" <> line | rest], meta) do
 86 |     line = remove_comments(line)
 87 |     [name, utcoff, rule, format | until] = String.split(line, ~r/\s/, trim: true, parts: 5)
 88 | 
 89 |     until =
 90 |       if until && Enum.any?(until), do: String.split(clean(List.first(until)), ~r/\s/, trim: true)
 91 | 
 92 |     from =
 93 |       case meta[:last] do
 94 |         %Zone{} = zone -> zone.until
 95 |         _ -> @min
 96 |       end
 97 | 
 98 |     until = to_dt(until) || @max
 99 |     rule_name = clean(rule)
100 |     zone_rules = find_rules(meta[:rules], rule_name, from, until)
101 |     format = clean(format)
102 |     utc_time = utcoff |> clean() |> to_time()
103 | 
104 |     zone = %Zone{
105 |       name: clean(name),
106 |       utc_offset_sec: to_seconds_after_midnight(utc_time),
107 |       utc_offset_hrs: to_offset(utc_time),
108 |       abbreviations:
109 |         zone_rules
110 |         |> Enum.filter(& &1.letter)
111 |         |> Enum.map(&String.replace(format, "%s", &1.letter))
112 |         |> add_root_abbreviation(format)
113 |         |> Enum.uniq(),
114 |       from: if(from != @min, do: from),
115 |       until: if(until != @max, do: until)
116 |     }
117 | 
118 |     :ets.insert(meta[:zones], {zone.name, zone})
119 | 
120 |     parse(rest, Map.put(meta, :last, zone))
121 |   end
122 | 
123 |   def parse(["Rule" <> line | rest], meta) do
124 |     line = remove_comments(line)
125 | 
126 |     [name, from_year, to_year, _, mon, on, at, save, letter] =
127 |       String.split(line, ~r/\t/, parts: 9)
128 | 
129 |     from_ndt = to_dt([clean(from_year), clean(mon), clean(on), clean(at)])
130 | 
131 |     to_year =
132 |       case to_year do
133 |         "only" -> from_year
134 |         "max" -> "9999"
135 |         v -> v
136 |       end
137 | 
138 |     to_ndt =
139 |       if clean(to_year) == :infinity,
140 |         do: :infinity,
141 |         else: to_dt([clean(to_year), mon, clean(on), clean(at)])
142 | 
143 |     rule = %Rule{
144 |       name: name,
145 |       from: from_ndt,
146 |       until: to_ndt,
147 |       save: save |> clean() |> to_time() |> to_seconds_after_midnight(),
148 |       letter: clean(letter)
149 |     }
150 | 
151 |     :ets.insert(meta[:rules], {rule.name, rule})
152 | 
153 |     parse(rest, Map.put(meta, :last, rule))
154 |   end
155 | 
156 |   def parse(["Link" <> line | rest], meta) do
157 |     line = remove_comments(line)
158 |     [target, name] = String.split(line, ~r/\s/, trim: true, parts: 2)
159 |     link_name = clean(name)
160 |     target = clean(target)
161 |     matching = :ets.lookup(meta[:zones], target)
162 | 
163 |     Enum.each(matching, fn {name, zone} ->
164 |       if link_name not in zone.aliases and zone.name != link_name do
165 |         :ets.delete_object(meta[:zones], {name, zone})
166 |         :ets.insert(meta[:zones], {zone.name, %{zone | aliases: [link_name | zone.aliases]}})
167 |       end
168 |     end)
169 | 
170 |     parse(rest, Map.delete(meta, :last))
171 |   end
172 | 
173 |   def parse([line | rest], meta) do
174 |     line = remove_comments(line)
175 | 
176 |     cond do
177 |       line == "" ->
178 |         parse(rest, meta)
179 | 
180 |       %Zone{} = last_zone = meta[:last] ->
181 |         parse(["Zone\t#{last_zone.name}\t" <> line | rest], meta)
182 |     end
183 |   end
184 | 
185 |   defp add_root_abbreviation(abbrevations, format) do
186 |     if String.contains?(format, "%s") do
187 |       abbrevations
188 |     else
189 |       Enum.concat(abbrevations, [format])
190 |     end
191 |   end
192 | 
193 |   defp find_rules(_rules, nil, _from, _until), do: []
194 | 
195 |   defp find_rules(rules, rule_name, from, until) do
196 |     rules = :ets.lookup(rules, rule_name)
197 | 
198 |     Enum.reduce(rules, [], fn {_, rule}, acc ->
199 |       if rule_name == rule.name and
200 |            not (NaiveDateTime.compare(rule.until, from || @min) == :lt or
201 |                   NaiveDateTime.compare(rule.from, until || @max) == :gt) do
202 |         [rule | acc]
203 |       else
204 |         acc
205 |       end
206 |     end)
207 |   end
208 | 
209 |   @mapping %{
210 |     "Jan" => 1,
211 |     "Feb" => 2,
212 |     "Mar" => 3,
213 |     "Apr" => 4,
214 |     "May" => 5,
215 |     "Jun" => 6,
216 |     "Jul" => 7,
217 |     "Aug" => 8,
218 |     "Sep" => 9,
219 |     "Oct" => 10,
220 |     "Nov" => 11,
221 |     "Dec" => 12
222 |   }
223 |   for {m, n} <- @mapping do
224 |     defp short_month_to_n(unquote(m)), do: unquote(n)
225 |   end
226 | 
227 |   defp to_dt(nil), do: nil
228 | 
229 |   defp to_dt([year]) do
230 |     {year, ""} = Integer.parse(year)
231 |     NaiveDateTime.new!(Date.new!(year, 1, 1), Time.new!(0, 0, 0))
232 |   end
233 | 
234 |   defp to_dt([year, month]) do
235 |     {year, ""} = Integer.parse(year)
236 |     NaiveDateTime.new!(Date.new!(year, short_month_to_n(month), 1), Time.new!(0, 0, 0))
237 |   end
238 | 
239 |   defp to_dt([year, month, day]) do
240 |     {year, ""} = Integer.parse(year)
241 |     month = short_month_to_n(month)
242 | 
243 |     date = handle_kday(year, month, day)
244 |     NaiveDateTime.new!(date, Time.new!(0, 0, 0))
245 |   end
246 | 
247 |   defp to_dt([year, month, day, "24:00"]) do
248 |     {year, ""} = Integer.parse(year)
249 |     month = short_month_to_n(month)
250 |     date = handle_kday(year, month, day)
251 |     NaiveDateTime.new!(date, Time.new!(23, 59, 0))
252 |   end
253 | 
254 |   defp to_dt([year, month, day, "24:00u"]) do
255 |     {year, ""} = Integer.parse(year)
256 |     month = short_month_to_n(month)
257 |     date = handle_kday(year, month, day)
258 |     DateTime.new!(date, Time.new!(23, 59, 0), "Etc/UTC")
259 |   end
260 | 
261 |   defp to_dt([year, month, day, "24:00s"]) do
262 |     {year, ""} = Integer.parse(year)
263 |     month = short_month_to_n(month)
264 |     date = handle_kday(year, month, day)
265 |     NaiveDateTime.new!(date, Time.new!(23, 59, 0))
266 |   end
267 | 
268 |   # Japan ? wat. kick it to the next day
269 |   defp to_dt([year, "Sep", "Sat>=8", "25:00"]) do
270 |     {year, ""} = Integer.parse(year)
271 |     date = Date.new!(year, 9, 9)
272 |     NaiveDateTime.new!(date, Time.new!(1, 0, 0))
273 |   end
274 | 
275 |   defp to_dt([year, month, day, time]) do
276 |     {year, ""} = Integer.parse(year)
277 |     month = short_month_to_n(month)
278 |     date = handle_kday(year, month, day)
279 |     [hour, minute | second] = String.split(time, ":", parts: 3, trim: true)
280 | 
281 |     {second, ""} =
282 |       if Enum.any?(second), do: second |> List.first() |> Integer.parse(), else: {0, ""}
283 | 
284 |     {hour, ""} = Integer.parse(hour)
285 | 
286 |     case Integer.parse(minute) do
287 |       {minute, "u"} ->
288 |         DateTime.new!(date, Time.new!(hour, minute, second), "Etc/UTC")
289 | 
290 |       {minute, note} when note in ["", "s"] ->
291 |         NaiveDateTime.new!(date, Time.new!(hour, minute, second))
292 |     end
293 |   end
294 | 
295 |   defp handle_kday(year, month, "last" <> day) do
296 |     year
297 |     |> Date.new!(month, 1)
298 |     |> Date.end_of_month()
299 |     |> Kday.last_kday(day_of_week(day))
300 |   end
301 | 
302 |   defp handle_kday(year, month, <<day_w::binary-size(3), ">=", day_n::binary>>) do
303 |     kday = day_of_week(day_w)
304 |     {day, ""} = Integer.parse(day_n)
305 | 
306 |     year
307 |     |> Date.new!(month, day)
308 |     |> Kday.kday_on_or_after(kday)
309 |   end
310 | 
311 |   defp handle_kday(year, month, <<day_w::binary-size(3), "<=", day_n::binary>>) do
312 |     kday = day_of_week(day_w)
313 |     {day, ""} = Integer.parse(day_n)
314 | 
315 |     year
316 |     |> Date.new!(month, day)
317 |     |> Kday.kday_on_or_before(kday)
318 |   end
319 | 
320 |   defp handle_kday(year, month, day) do
321 |     {day, ""} = Integer.parse(day)
322 |     Date.new!(year, month, day)
323 |   end
324 | 
325 |   @mapping %{"Mon" => 1, "Tue" => 2, "Wed" => 3, "Thu" => 4, "Fri" => 5, "Sat" => 6, "Sun" => 7}
326 |   for {d, n} <- @mapping do
327 |     defp day_of_week(unquote(d)), do: unquote(n)
328 |   end
329 | 
330 |   defp to_time(nil), do: nil
331 |   defp to_time(0), do: 0
332 |   defp to_time(time) when byte_size(time) == 1, do: to_time("0" <> time <> ":00:00")
333 |   defp to_time("-" <> time) when byte_size(time) == 1, do: to_time("-0" <> time <> ":00:00")
334 |   defp to_time(time) when byte_size(time) == 2, do: to_time(time <> ":00:00")
335 |   defp to_time("+" <> time) when byte_size(time) == 2, do: to_time(time <> ":00:00")
336 |   defp to_time("-" <> time) when byte_size(time) == 2, do: to_time("-" <> time <> ":00:00")
337 |   defp to_time(time) when byte_size(time) in [4, 7], do: to_time("0" <> time)
338 |   defp to_time(time) when byte_size(time) == 5, do: to_time(time <> ":00")
339 |   defp to_time("-" <> time) when byte_size(time) == 5, do: to_time("-" <> time <> ":00")
340 |   defp to_time("-" <> time) when byte_size(time) == 7, do: to_time("-0" <> time)
341 |   defp to_time("-" <> time) when byte_size(time) == 8, do: {"-", Time.from_iso8601!(time)}
342 |   defp to_time(time) when byte_size(time) == 8, do: {"+", Time.from_iso8601!(time)}
343 | 
344 |   defp to_offset({sign, time}) do
345 |     [
346 |       sign,
347 |       String.pad_leading("#{time.hour}", 2, "0"),
348 |       String.pad_leading("#{time.minute}", 2, "0")
349 |     ]
350 |     |> Enum.join()
351 |   end
352 | 
353 |   defp to_seconds_after_midnight({"-", time}) do
354 |     {seconds, _} = Time.to_seconds_after_midnight(time)
355 |     -seconds
356 |   end
357 | 
358 |   defp to_seconds_after_midnight({"+", time}) do
359 |     {seconds, _} = Time.to_seconds_after_midnight(time)
360 |     seconds
361 |   end
362 | 
363 |   defp clean("-"), do: nil
364 |   defp clean(""), do: nil
365 |   defp clean(v) when is_binary(v), do: String.trim(v)
366 |   defp clean(v), do: v
367 | 
368 |   defp read_file do
369 |     Enum.map_join(@sources, "\n", &File.read!(Application.app_dir(:date_time_parser, &1)))
370 |   end
371 | 
372 |   defp remove_comments(line),
373 |     do: line |> String.split("#", trim: true, parts: 2) |> List.first() |> String.trim()
374 | end
375 | 


--------------------------------------------------------------------------------
/priv/tzdata2022g/antarctica:
--------------------------------------------------------------------------------
  1 | # tzdb data for Antarctica and environs
  2 | 
  3 | # This file is in the public domain, so clarified as of
  4 | # 2009-05-17 by Arthur David Olson.
  5 | 
  6 | # From Paul Eggert (1999-11-15):
  7 | # To keep things manageable, we list only locations occupied year-round; see
  8 | # COMNAP - Stations and Bases
  9 | # http://www.comnap.aq/comnap/comnap.nsf/P/Stations/
 10 | # and
 11 | # Summary of the Peri-Antarctic Islands (1998-07-23)
 12 | # http://www.spri.cam.ac.uk/bob/periant.htm
 13 | # for information.
 14 | # Unless otherwise specified, we have no time zone information.
 15 | 
 16 | # FORMAT is '-00' and STDOFF is 0 for locations while uninhabited.
 17 | 
 18 | # Argentina - year-round bases
 19 | # Belgrano II, Confin Coast, -770227-0343737, since 1972-02-05
 20 | # Carlini, Potter Cove, King George Island, -6414-0602320, since 1982-01
 21 | # Esperanza, Hope Bay, -6323-05659, since 1952-12-17
 22 | # Marambio, -6414-05637, since 1969-10-29
 23 | # Orcadas, Laurie I, -6016-04444, since 1904-02-22
 24 | # San Martín, Barry I, -6808-06706, since 1951-03-21
 25 | #	(except 1960-03 / 1976-03-21)
 26 | 
 27 | # Australia - territories
 28 | # Heard Island, McDonald Islands (uninhabited)
 29 | #	previously sealers and scientific personnel wintered
 30 | #	Margaret Turner reports
 31 | #	https://web.archive.org/web/20021204222245/http://www.dstc.qut.edu.au/DST/marg/daylight.html
 32 | #	(1999-09-30) that they're UT +05, with no DST;
 33 | #	presumably this is when they have visitors.
 34 | #
 35 | # year-round bases
 36 | # Casey, Bailey Peninsula, -6617+11032, since 1969
 37 | # Davis, Vestfold Hills, -6835+07759, since 1957-01-13
 38 | #	(except 1964-11 - 1969-02)
 39 | # Mawson, Holme Bay, -6736+06253, since 1954-02-13
 40 | 
 41 | # From Steffen Thorsen (2009-03-11):
 42 | # Three Australian stations in Antarctica have changed their time zone:
 43 | # Casey moved from UTC+8 to UTC+11
 44 | # Davis moved from UTC+7 to UTC+5
 45 | # Mawson moved from UTC+6 to UTC+5
 46 | # The changes occurred on 2009-10-18 at 02:00 (local times).
 47 | #
 48 | # Government source: (Australian Antarctic Division)
 49 | # http://www.aad.gov.au/default.asp?casid=37079
 50 | #
 51 | # We have more background information here:
 52 | # https://www.timeanddate.com/news/time/antarctica-new-times.html
 53 | 
 54 | # From Steffen Thorsen (2010-03-10):
 55 | # We got these changes from the Australian Antarctic Division: ...
 56 | #
 57 | # - Casey station reverted to its normal time of UTC+8 on 5 March 2010.
 58 | # The change to UTC+11 is being considered as a regular summer thing but
 59 | # has not been decided yet.
 60 | #
 61 | # - Davis station will revert to its normal time of UTC+7 at 10 March 2010
 62 | # 20:00 UTC.
 63 | #
 64 | # - Mawson station stays on UTC+5.
 65 | #
 66 | # Background:
 67 | # https://www.timeanddate.com/news/time/antartica-time-changes-2010.html
 68 | 
 69 | # From Steffen Thorsen (2016-10-28):
 70 | # Australian Antarctica Division informed us that Casey changed time
 71 | # zone to UTC+11 in "the morning of 22nd October 2016".
 72 | 
 73 | # From Steffen Thorsen (2020-10-02, as corrected):
 74 | # Based on information we have received from the Australian Antarctic
 75 | # Division, Casey station and Macquarie Island station will move to Tasmanian
 76 | # daylight savings time on Sunday 4 October. This will take effect from 0001
 77 | # hrs on Sunday 4 October 2020 and will mean Casey and Macquarie Island will
 78 | # be on the same time zone as Hobart.  Some past dates too for this 3 hour
 79 | # time change back and forth between UTC+8 and UTC+11 for Casey:
 80 | # - 2018 Oct  7 4:00 - 2019 Mar 17 3:00 - 2019 Oct  4 3:00 - 2020 Mar  8 3:00
 81 | # and now - 2020 Oct  4 0:01
 82 | 
 83 | # Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
 84 | Zone Antarctica/Casey	 0	-	-00	1969
 85 | 			 8:00	-	+08	2009 Oct 18  2:00
 86 | 			11:00	-	+11	2010 Mar  5  2:00
 87 | 			 8:00	-	+08	2011 Oct 28  2:00
 88 | 			11:00	-	+11	2012 Feb 21 17:00u
 89 | 			 8:00	-	+08	2016 Oct 22
 90 | 			11:00	-	+11	2018 Mar 11  4:00
 91 | 			 8:00	-	+08	2018 Oct  7  4:00
 92 | 			11:00	-	+11	2019 Mar 17  3:00
 93 | 			 8:00	-	+08	2019 Oct  4  3:00
 94 | 			11:00	-	+11	2020 Mar  8  3:00
 95 | 			 8:00	-	+08	2020 Oct  4  0:01
 96 | 			11:00	-	+11
 97 | Zone Antarctica/Davis	0	-	-00	1957 Jan 13
 98 | 			7:00	-	+07	1964 Nov
 99 | 			0	-	-00	1969 Feb
100 | 			7:00	-	+07	2009 Oct 18  2:00
101 | 			5:00	-	+05	2010 Mar 10 20:00u
102 | 			7:00	-	+07	2011 Oct 28  2:00
103 | 			5:00	-	+05	2012 Feb 21 20:00u
104 | 			7:00	-	+07
105 | Zone Antarctica/Mawson	0	-	-00	1954 Feb 13
106 | 			6:00	-	+06	2009 Oct 18  2:00
107 | 			5:00	-	+05
108 | # References:
109 | # Casey Weather (1998-02-26)
110 | # http://www.antdiv.gov.au/aad/exop/sfo/casey/casey_aws.html
111 | # Davis Station, Antarctica (1998-02-26)
112 | # http://www.antdiv.gov.au/aad/exop/sfo/davis/video.html
113 | # Mawson Station, Antarctica (1998-02-25)
114 | # http://www.antdiv.gov.au/aad/exop/sfo/mawson/video.html
115 | 
116 | # Belgium - year-round base
117 | # Princess Elisabeth, Queen Maud Land, -713412+0231200, since 2007
118 | 
119 | # Brazil - year-round base
120 | # Ferraz, King George Island, -6205+05824, since 1983/4
121 | 
122 | # Bulgaria - year-round base
123 | # St. Kliment Ohridski, Livingston Island, -623829-0602153, since 1988
124 | 
125 | # Chile - year-round bases and towns
126 | # Escudero, South Shetland Is, -621157-0585735, since 1994
127 | # Frei Montalva, King George Island, -6214-05848, since 1969-03-07
128 | # O'Higgins, Antarctic Peninsula, -6319-05704, since 1948-02
129 | # Prat, -6230-05941
130 | # Villa Las Estrellas (a town), around the Frei base, since 1984-04-09
131 | # These locations employ Region of Magallanes time; use
132 | # TZ='America/Punta_Arenas'.
133 | 
134 | # China - year-round bases
135 | # Great Wall, King George Island, -6213-05858, since 1985-02-20
136 | # Zhongshan, Larsemann Hills, Prydz Bay, -6922+07623, since 1989-02-26
137 | 
138 | # France - year-round bases (also see "France & Italy")
139 | #
140 | # From Antoine Leca (1997-01-20):
141 | # Time data entries are from Nicole Pailleau at the IFRTP
142 | # (French Institute for Polar Research and Technology).
143 | # She confirms that French Southern Territories and Terre Adélie bases
144 | # don't observe daylight saving time, even if Terre Adélie supplies came
145 | # from Tasmania.
146 | #
147 | # French Southern Territories with year-round inhabitants
148 | #
149 | # Alfred Faure, Possession Island, Crozet Islands, -462551+0515152, since 1964;
150 | #	sealing & whaling stations operated variously 1802/1911+;
151 | #	see Asia/Dubai.
152 | #
153 | # Martin-de-Viviès, Amsterdam Island, -374105+0773155, since 1950
154 | # Port-aux-Français, Kerguelen Islands, -492110+0701303, since 1951;
155 | #	whaling & sealing station operated 1908/1914, 1920/1929, and 1951/1956
156 | #
157 | # St Paul Island - near Amsterdam, uninhabited
158 | #	fishing stations operated variously 1819/1931
159 | #
160 | # Kerguelen - see Indian/Maldives.
161 | #
162 | # year-round base in the main continent
163 | # Dumont d'Urville - see Pacific/Port_Moresby.
164 | 
165 | # France & Italy - year-round base
166 | # Concordia, -750600+1232000, since 2005
167 | 
168 | # Germany - year-round base
169 | # Neumayer III, -704080-0081602, since 2009
170 | 
171 | # India - year-round bases
172 | # Bharati, -692428+0761114, since 2012
173 | # Maitri, -704558+0114356, since 1989
174 | 
175 | # Italy - year-round base (also see "France & Italy")
176 | # Zuchelli, Terra Nova Bay, -744140+1640647, since 1986
177 | 
178 | # Japan - year-round bases
179 | # See Asia/Riyadh.
180 | 
181 | # S Korea - year-round base
182 | # Jang Bogo, Terra Nova Bay, -743700+1641205 since 2014
183 | # King Sejong, King George Island, -6213-05847, since 1988
184 | 
185 | # New Zealand - claims
186 | # Balleny Islands (never inhabited)
187 | # Scott Island (never inhabited)
188 | #
189 | # year-round base
190 | # Scott Base, Ross Island, since 1957-01.
191 | # See Pacific/Auckland.
192 | 
193 | # Norway - territories
194 | # Bouvet (never inhabited)
195 | #
196 | # claims
197 | # Peter I Island (never inhabited)
198 | #
199 | # year-round base
200 | # Troll, Queen Maud Land, -720041+0023206, since 2005-02-12
201 | #
202 | # From Paul-Inge Flakstad (2014-03-10):
203 | # I recently had a long dialog about this with the developer of timegenie.com.
204 | # In the absence of specific dates, he decided to choose some likely ones:
205 | #   GMT +1 - From March 1 to the last Sunday in March
206 | #   GMT +2 - From the last Sunday in March until the last Sunday in October
207 | #   GMT +1 - From the last Sunday in October until November 7
208 | #   GMT +0 - From November 7 until March 1
209 | # The dates for switching to and from UTC+0 will probably not be absolutely
210 | # correct, but they should be quite close to the actual dates.
211 | #
212 | # From Paul Eggert (2014-03-21):
213 | # The CET-switching Troll rules require zic from tz 2014b or later, so as
214 | # suggested by Bengt-Inge Larsson comment them out for now, and approximate
215 | # with only UTC and CEST.  Uncomment them when 2014b is more prevalent.
216 | #
217 | # Rule	NAME	FROM	TO	-	IN	ON	AT	SAVE	LETTER/S
218 | #Rule	Troll	2005	max	-	Mar	 1	1:00u	1:00	+01
219 | Rule	Troll	2005	max	-	Mar	lastSun	1:00u	2:00	+02
220 | #Rule	Troll	2005	max	-	Oct	lastSun	1:00u	1:00	+01
221 | #Rule	Troll	2004	max	-	Nov	 7	1:00u	0:00	+00
222 | # Remove the following line when uncommenting the above '#Rule' lines.
223 | Rule	Troll	2004	max	-	Oct	lastSun	1:00u	0:00	+00
224 | # Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
225 | Zone Antarctica/Troll	0	-	-00	2005 Feb 12
226 | 			0:00	Troll	%s
227 | 
228 | # Poland - year-round base
229 | # Arctowski, King George Island, -620945-0582745, since 1977
230 | 
231 | # Romania - year-bound base
232 | # Law-Racoviță, Larsemann Hills, -692319+0762251, since 1986
233 | 
234 | # Russia - year-round bases
235 | # Bellingshausen, King George Island, -621159-0585337, since 1968-02-22
236 | # Mirny, Davis coast, -6633+09301, since 1956-02
237 | # Molodezhnaya, Alasheyev Bay, -6740+04551,
238 | #	year-round from 1962-02 to 1999-07-01
239 | # Novolazarevskaya, Queen Maud Land, -7046+01150,
240 | #	year-round from 1960/61 to 1992
241 | 
242 | # Vostok, since 1957-12-16, temporarily closed 1994-02/1994-11
243 | # See Asia/Urumqi.
244 | 
245 | # S Africa - year-round bases
246 | # Marion Island, -4653+03752
247 | # SANAE IV, Vesleskarvet, Queen Maud Land, -714022-0025026, since 1997
248 | 
249 | # Ukraine - year-round base
250 | # Vernadsky (formerly Faraday), Galindez Island, -651445-0641526, since 1954
251 | 
252 | # United Kingdom
253 | #
254 | # British Antarctic Territories (BAT) claims
255 | # South Orkney Islands
256 | #	scientific station from 1903
257 | #	whaling station at Signy I 1920/1926
258 | # South Shetland Islands
259 | #
260 | # year-round bases
261 | # Bird Island, South Georgia, -5400-03803, since 1983
262 | # Deception Island, -6259-06034, whaling station 1912/1931,
263 | #	scientific station 1943/1967,
264 | #	previously sealers and a scientific expedition wintered by accident,
265 | #	and a garrison was deployed briefly
266 | # Halley, Coates Land, -7535-02604, since 1956-01-06
267 | #	Halley is on a moving ice shelf and is periodically relocated
268 | #	so that it is never more than 10km from its nominal location.
269 | # Rothera, Adelaide Island, -6734-6808, since 1976-12-01
270 | #
271 | # From Paul Eggert (2002-10-22)
272 | # <http://webexhibits.org/daylightsaving/g.html> says Rothera is -03 all year.
273 | #
274 | # Zone	NAME		STDOFF	RULES	FORMAT	[UNTIL]
275 | Zone Antarctica/Rothera	0	-	-00	1976 Dec  1
276 | 			-3:00	-	-03
277 | 
278 | # Uruguay - year round base
279 | # Artigas, King George Island, -621104-0585107
280 | 
281 | # USA - year-round bases
282 | #
283 | # Palmer, Anvers Island, since 1965 (moved 2 miles in 1968)
284 | # See 'southamerica' for Antarctica/Palmer, since it uses South American DST.
285 | #
286 | # McMurdo Station, Ross Island, since 1955-12
287 | # Amundsen-Scott South Pole Station, continuously occupied since 1956-11-20
288 | #
289 | # From Chris Carrier (1996-06-27):
290 | # Siple, the first commander of the South Pole station,
291 | # stated that he would have liked to have kept GMT at the station,
292 | # but that he found it more convenient to keep GMT+12
293 | # as supplies for the station were coming from McMurdo Sound,
294 | # which was on GMT+12 because New Zealand was on GMT+12 all year
295 | # at that time (1957).  (Source: Siple's book 90 Degrees South.)
296 | #
297 | # From Susan Smith
298 | # http://www.cybertours.com/whs/pole10.html
299 | # (1995-11-13 16:24:56 +1300, no longer available):
300 | # We use the same time as McMurdo does.
301 | # And they use the same time as Christchurch, NZ does....
302 | # One last quirk about South Pole time.
303 | # All the electric clocks are usually wrong.
304 | # Something about the generators running at 60.1hertz or something
305 | # makes all of the clocks run fast.  So every couple of days,
306 | # we have to go around and set them back 5 minutes or so.
307 | # Maybe if we let them run fast all of the time, we'd get to leave here sooner!!
308 | #
309 | # See Pacific/Auckland.
310 | 


--------------------------------------------------------------------------------
/priv/tzdata2022g/backward:
--------------------------------------------------------------------------------
  1 | # tzdb links for backward compatibility
  2 | 
  3 | # This file is in the public domain, so clarified as of
  4 | # 2009-05-17 by Arthur David Olson.
  5 | 
  6 | # This file provides links from old or merged timezone names to current ones.
  7 | # Many names changed in 1993 and in 1995, and many merged names moved here
  8 | # in the period from 2013 through 2022.  Several of these names are
  9 | # also present in the file 'backzone', which has data important only
 10 | # for pre-1970 timestamps and so is out of scope for tzdb proper.
 11 | 
 12 | # Although this file is optional and tzdb will work if you omit it by
 13 | # building with 'make BACKWARD=', in practice downstream users
 14 | # typically use this file for backward compatibility.
 15 | 
 16 | # This file is divided into sections, one for each major reason for a
 17 | # backward compatibility link.  Each section is sorted by link name.
 18 | 
 19 | # A "#= TARGET1" comment labels each link inserted only because some
 20 | # .zi parsers (including tzcode through 2022e) mishandle links to links.
 21 | # The comment says what the target would be if these parsers were fixed
 22 | # so that data could contain links to links.  For example, the line
 23 | # "Link Australia/Sydney Australia/ACT #= Australia/Canberra" would be
 24 | # "Link Australia/Canberra Australia/ACT" were it not that data lines
 25 | # refrain from linking to links like Australia/Canberra, which means
 26 | # the Australia/ACT line links instead to Australia/Sydney,
 27 | # Australia/Canberra's target.
 28 | 
 29 | 
 30 | # Pre-1993 naming conventions
 31 | 
 32 | # Link	TARGET			LINK-NAME	#= TARGET1
 33 | Link	Australia/Sydney	Australia/ACT	#= Australia/Canberra
 34 | Link	Australia/Lord_Howe	Australia/LHI
 35 | Link	Australia/Sydney	Australia/NSW
 36 | Link	Australia/Darwin	Australia/North
 37 | Link	Australia/Brisbane	Australia/Queensland
 38 | Link	Australia/Adelaide	Australia/South
 39 | Link	Australia/Hobart	Australia/Tasmania
 40 | Link	Australia/Melbourne	Australia/Victoria
 41 | Link	Australia/Perth		Australia/West
 42 | Link	Australia/Broken_Hill	Australia/Yancowinna
 43 | Link	America/Rio_Branco	Brazil/Acre	#= America/Porto_Acre
 44 | Link	America/Noronha		Brazil/DeNoronha
 45 | Link	America/Sao_Paulo	Brazil/East
 46 | Link	America/Manaus		Brazil/West
 47 | Link	America/Halifax		Canada/Atlantic
 48 | Link	America/Winnipeg	Canada/Central
 49 | # This line is commented out, as the name exceeded the 14-character limit
 50 | # and was an unused misnomer.
 51 | #Link	America/Regina		Canada/East-Saskatchewan
 52 | Link	America/Toronto		Canada/Eastern
 53 | Link	America/Edmonton	Canada/Mountain
 54 | Link	America/St_Johns	Canada/Newfoundland
 55 | Link	America/Vancouver	Canada/Pacific
 56 | Link	America/Regina		Canada/Saskatchewan
 57 | Link	America/Whitehorse	Canada/Yukon
 58 | Link	America/Santiago	Chile/Continental
 59 | Link	Pacific/Easter		Chile/EasterIsland
 60 | Link	America/Havana		Cuba
 61 | Link	Africa/Cairo		Egypt
 62 | Link	Europe/Dublin		Eire
 63 | # Vanguard section, for most .zi parsers.
 64 | #Link	GMT			Etc/GMT
 65 | #Link	GMT			Etc/GMT+0
 66 | #Link	GMT			Etc/GMT-0
 67 | #Link	GMT			Etc/GMT0
 68 | #Link	GMT			Etc/Greenwich
 69 | # Rearguard section, for TZUpdater 2.3.2 and earlier.
 70 | Link	Etc/GMT			Etc/GMT+0
 71 | Link	Etc/GMT			Etc/GMT-0
 72 | Link	Etc/GMT			Etc/GMT0
 73 | Link	Etc/GMT			Etc/Greenwich
 74 | # End of rearguard section.
 75 | Link	Etc/UTC			Etc/UCT
 76 | Link	Etc/UTC			Etc/Universal
 77 | Link	Etc/UTC			Etc/Zulu
 78 | Link	Europe/London		GB
 79 | Link	Europe/London		GB-Eire
 80 | # Vanguard section, for most .zi parsers.
 81 | #Link	GMT			GMT+0
 82 | #Link	GMT			GMT-0
 83 | #Link	GMT			GMT0
 84 | #Link	GMT			Greenwich
 85 | # Rearguard section, for TZUpdater 2.3.2 and earlier.
 86 | Link	Etc/GMT			GMT+0
 87 | Link	Etc/GMT			GMT-0
 88 | Link	Etc/GMT			GMT0
 89 | Link	Etc/GMT			Greenwich
 90 | # End of rearguard section.
 91 | Link	Asia/Hong_Kong		Hongkong
 92 | Link	Africa/Abidjan		Iceland	#= Atlantic/Reykjavik
 93 | Link	Asia/Tehran		Iran
 94 | Link	Asia/Jerusalem		Israel
 95 | Link	America/Jamaica		Jamaica
 96 | Link	Asia/Tokyo		Japan
 97 | Link	Pacific/Kwajalein	Kwajalein
 98 | Link	Africa/Tripoli		Libya
 99 | Link	America/Tijuana		Mexico/BajaNorte
100 | Link	America/Mazatlan	Mexico/BajaSur
101 | Link	America/Mexico_City	Mexico/General
102 | Link	Pacific/Auckland	NZ
103 | Link	Pacific/Chatham		NZ-CHAT
104 | Link	America/Denver		Navajo	#= America/Shiprock
105 | Link	Asia/Shanghai		PRC
106 | Link	Europe/Warsaw		Poland
107 | Link	Europe/Lisbon		Portugal
108 | Link	Asia/Taipei		ROC
109 | Link	Asia/Seoul		ROK
110 | Link	Asia/Singapore		Singapore
111 | Link	Europe/Istanbul		Turkey
112 | Link	Etc/UTC			UCT
113 | Link	America/Anchorage	US/Alaska
114 | Link	America/Adak		US/Aleutian
115 | Link	America/Phoenix		US/Arizona
116 | Link	America/Chicago		US/Central
117 | Link	America/Indiana/Indianapolis	US/East-Indiana
118 | Link	America/New_York	US/Eastern
119 | Link	Pacific/Honolulu	US/Hawaii
120 | Link	America/Indiana/Knox	US/Indiana-Starke
121 | Link	America/Detroit		US/Michigan
122 | Link	America/Denver		US/Mountain
123 | Link	America/Los_Angeles	US/Pacific
124 | Link	Pacific/Pago_Pago	US/Samoa
125 | Link	Etc/UTC			UTC
126 | Link	Etc/UTC			Universal
127 | Link	Europe/Moscow		W-SU
128 | Link	Etc/UTC			Zulu
129 | 
130 | 
131 | # Two-part names that were renamed mostly to three-part names in 1995
132 | 
133 | # Link	TARGET				LINK-NAME	#= TARGET1
134 | Link	America/Argentina/Buenos_Aires	America/Buenos_Aires
135 | Link	America/Argentina/Catamarca	America/Catamarca
136 | Link	America/Argentina/Cordoba	America/Cordoba
137 | Link	America/Indiana/Indianapolis	America/Indianapolis
138 | Link	America/Argentina/Jujuy		America/Jujuy
139 | Link	America/Indiana/Knox		America/Knox_IN
140 | Link	America/Kentucky/Louisville	America/Louisville
141 | Link	America/Argentina/Mendoza	America/Mendoza
142 | Link	America/Puerto_Rico		America/Virgin	#= America/St_Thomas
143 | Link	Pacific/Pago_Pago		Pacific/Samoa
144 | 
145 | 
146 | # Pre-2013 practice, which typically had a Zone per zone.tab line
147 | 
148 | # Link	TARGET			LINK-NAME
149 | Link	Africa/Abidjan		Africa/Accra
150 | Link	Africa/Nairobi		Africa/Addis_Ababa
151 | Link	Africa/Nairobi		Africa/Asmara
152 | Link	Africa/Abidjan		Africa/Bamako
153 | Link	Africa/Lagos		Africa/Bangui
154 | Link	Africa/Abidjan		Africa/Banjul
155 | Link	Africa/Maputo		Africa/Blantyre
156 | Link	Africa/Lagos		Africa/Brazzaville
157 | Link	Africa/Maputo		Africa/Bujumbura
158 | Link	Africa/Abidjan		Africa/Conakry
159 | Link	Africa/Abidjan		Africa/Dakar
160 | Link	Africa/Nairobi		Africa/Dar_es_Salaam
161 | Link	Africa/Nairobi		Africa/Djibouti
162 | Link	Africa/Lagos		Africa/Douala
163 | Link	Africa/Abidjan		Africa/Freetown
164 | Link	Africa/Maputo		Africa/Gaborone
165 | Link	Africa/Maputo		Africa/Harare
166 | Link	Africa/Nairobi		Africa/Kampala
167 | Link	Africa/Maputo		Africa/Kigali
168 | Link	Africa/Lagos		Africa/Kinshasa
169 | Link	Africa/Lagos		Africa/Libreville
170 | Link	Africa/Abidjan		Africa/Lome
171 | Link	Africa/Lagos		Africa/Luanda
172 | Link	Africa/Maputo		Africa/Lubumbashi
173 | Link	Africa/Maputo		Africa/Lusaka
174 | Link	Africa/Lagos		Africa/Malabo
175 | Link	Africa/Johannesburg	Africa/Maseru
176 | Link	Africa/Johannesburg	Africa/Mbabane
177 | Link	Africa/Nairobi		Africa/Mogadishu
178 | Link	Africa/Lagos		Africa/Niamey
179 | Link	Africa/Abidjan		Africa/Nouakchott
180 | Link	Africa/Abidjan		Africa/Ouagadougou
181 | Link	Africa/Lagos		Africa/Porto-Novo
182 | Link	America/Puerto_Rico	America/Anguilla
183 | Link	America/Puerto_Rico	America/Antigua
184 | Link	America/Puerto_Rico	America/Aruba
185 | Link	America/Panama		America/Atikokan
186 | Link	America/Puerto_Rico	America/Blanc-Sablon
187 | Link	America/Panama		America/Cayman
188 | Link	America/Phoenix		America/Creston
189 | Link	America/Puerto_Rico	America/Curacao
190 | Link	America/Puerto_Rico	America/Dominica
191 | Link	America/Puerto_Rico	America/Grenada
192 | Link	America/Puerto_Rico	America/Guadeloupe
193 | Link	America/Puerto_Rico	America/Kralendijk
194 | Link	America/Puerto_Rico	America/Lower_Princes
195 | Link	America/Puerto_Rico	America/Marigot
196 | Link	America/Puerto_Rico	America/Montserrat
197 | Link	America/Toronto		America/Nassau
198 | Link	America/Puerto_Rico	America/Port_of_Spain
199 | Link	America/Puerto_Rico	America/St_Barthelemy
200 | Link	America/Puerto_Rico	America/St_Kitts
201 | Link	America/Puerto_Rico	America/St_Lucia
202 | Link	America/Puerto_Rico	America/St_Thomas
203 | Link	America/Puerto_Rico	America/St_Vincent
204 | Link	America/Puerto_Rico	America/Tortola
205 | Link	Pacific/Port_Moresby	Antarctica/DumontDUrville
206 | Link	Pacific/Auckland	Antarctica/McMurdo
207 | Link	Asia/Riyadh		Antarctica/Syowa
208 | Link	Asia/Urumqi		Antarctica/Vostok
209 | Link	Europe/Berlin		Arctic/Longyearbyen
210 | Link	Asia/Riyadh		Asia/Aden
211 | Link	Asia/Qatar		Asia/Bahrain
212 | Link	Asia/Kuching		Asia/Brunei
213 | Link	Asia/Singapore		Asia/Kuala_Lumpur
214 | Link	Asia/Riyadh		Asia/Kuwait
215 | Link	Asia/Dubai		Asia/Muscat
216 | Link	Asia/Bangkok		Asia/Phnom_Penh
217 | Link	Asia/Bangkok		Asia/Vientiane
218 | Link	Africa/Abidjan		Atlantic/Reykjavik
219 | Link	Africa/Abidjan		Atlantic/St_Helena
220 | Link	Europe/Brussels		Europe/Amsterdam
221 | Link	Europe/Prague		Europe/Bratislava
222 | Link	Europe/Zurich		Europe/Busingen
223 | Link	Europe/Berlin		Europe/Copenhagen
224 | Link	Europe/London		Europe/Guernsey
225 | Link	Europe/London		Europe/Isle_of_Man
226 | Link	Europe/London		Europe/Jersey
227 | Link	Europe/Belgrade		Europe/Ljubljana
228 | Link	Europe/Brussels		Europe/Luxembourg
229 | Link	Europe/Helsinki		Europe/Mariehamn
230 | Link	Europe/Paris		Europe/Monaco
231 | Link	Europe/Berlin		Europe/Oslo
232 | Link	Europe/Belgrade		Europe/Podgorica
233 | Link	Europe/Rome		Europe/San_Marino
234 | Link	Europe/Belgrade		Europe/Sarajevo
235 | Link	Europe/Belgrade		Europe/Skopje
236 | Link	Europe/Berlin		Europe/Stockholm
237 | Link	Europe/Zurich		Europe/Vaduz
238 | Link	Europe/Rome		Europe/Vatican
239 | Link	Europe/Belgrade		Europe/Zagreb
240 | Link	Africa/Nairobi		Indian/Antananarivo
241 | Link	Asia/Bangkok		Indian/Christmas
242 | Link	Asia/Yangon		Indian/Cocos
243 | Link	Africa/Nairobi		Indian/Comoro
244 | Link	Indian/Maldives		Indian/Kerguelen
245 | Link	Asia/Dubai		Indian/Mahe
246 | Link	Africa/Nairobi		Indian/Mayotte
247 | Link	Asia/Dubai		Indian/Reunion
248 | Link	Pacific/Port_Moresby	Pacific/Chuuk
249 | Link	Pacific/Tarawa		Pacific/Funafuti
250 | Link	Pacific/Tarawa		Pacific/Majuro
251 | Link	Pacific/Pago_Pago	Pacific/Midway
252 | Link	Pacific/Guadalcanal	Pacific/Pohnpei
253 | Link	Pacific/Guam		Pacific/Saipan
254 | Link	Pacific/Tarawa		Pacific/Wake
255 | Link	Pacific/Tarawa		Pacific/Wallis
256 | 
257 | 
258 | # Non-zone.tab locations with timestamps since 1970 that duplicate
259 | # those of an existing location
260 | 
261 | # Link	TARGET			LINK-NAME
262 | Link	Africa/Abidjan		Africa/Timbuktu
263 | Link	America/Argentina/Catamarca	America/Argentina/ComodRivadavia
264 | Link	America/Adak		America/Atka
265 | Link	America/Panama		America/Coral_Harbour
266 | Link	America/Tijuana		America/Ensenada
267 | Link	America/Indiana/Indianapolis	America/Fort_Wayne
268 | Link	America/Toronto		America/Montreal
269 | Link	America/Toronto		America/Nipigon
270 | Link	America/Iqaluit		America/Pangnirtung
271 | Link	America/Rio_Branco	America/Porto_Acre
272 | Link	America/Winnipeg	America/Rainy_River
273 | Link	America/Argentina/Cordoba	America/Rosario
274 | Link	America/Tijuana		America/Santa_Isabel
275 | Link	America/Denver		America/Shiprock
276 | Link	America/Toronto		America/Thunder_Bay
277 | Link	Pacific/Auckland	Antarctica/South_Pole
278 | Link	Asia/Shanghai		Asia/Chongqing
279 | Link	Asia/Shanghai		Asia/Harbin
280 | Link	Asia/Urumqi		Asia/Kashgar
281 | Link	Asia/Jerusalem		Asia/Tel_Aviv
282 | Link	Europe/Berlin		Atlantic/Jan_Mayen
283 | Link	Australia/Sydney	Australia/Canberra
284 | Link	Australia/Hobart	Australia/Currie
285 | Link	Europe/London		Europe/Belfast
286 | Link	Europe/Chisinau		Europe/Tiraspol
287 | Link	Europe/Kyiv		Europe/Uzhgorod
288 | Link	Europe/Kyiv		Europe/Zaporozhye
289 | Link	Pacific/Kanton		Pacific/Enderbury
290 | Link	Pacific/Honolulu	Pacific/Johnston
291 | Link	Pacific/Port_Moresby	Pacific/Yap
292 | 
293 | 
294 | # Alternate names for the same location
295 | 
296 | # Link	TARGET			LINK-NAME	#= TARGET1
297 | Link	Africa/Nairobi		Africa/Asmera	#= Africa/Asmara
298 | Link	America/Nuuk		America/Godthab
299 | Link	Asia/Ashgabat		Asia/Ashkhabad
300 | Link	Asia/Kolkata		Asia/Calcutta
301 | Link	Asia/Shanghai		Asia/Chungking	#= Asia/Chongqing
302 | Link	Asia/Dhaka		Asia/Dacca
303 | # Istanbul is in both continents.
304 | Link	Europe/Istanbul		Asia/Istanbul
305 | Link	Asia/Kathmandu		Asia/Katmandu
306 | Link	Asia/Macau		Asia/Macao
307 | Link	Asia/Yangon		Asia/Rangoon
308 | Link	Asia/Ho_Chi_Minh	Asia/Saigon
309 | Link	Asia/Thimphu		Asia/Thimbu
310 | Link	Asia/Makassar		Asia/Ujung_Pandang
311 | Link	Asia/Ulaanbaatar	Asia/Ulan_Bator
312 | Link	Atlantic/Faroe		Atlantic/Faeroe
313 | Link	Europe/Kyiv		Europe/Kiev
314 | # Classically, Cyprus is in Asia; e.g. see Herodotus, Histories, I.72.
315 | # However, for various reasons many users expect to find it under Europe.
316 | Link	Asia/Nicosia		Europe/Nicosia
317 | Link	Pacific/Guadalcanal	Pacific/Ponape	#= Pacific/Pohnpei
318 | Link	Pacific/Port_Moresby	Pacific/Truk	#= Pacific/Chuuk
319 | 


--------------------------------------------------------------------------------
/lib/date_time_parser/timezone_abbreviations.ex:
--------------------------------------------------------------------------------
  1 | defmodule DateTimeParser.TimezoneAbbreviations do
  2 |   @moduledoc """
  3 |   Fetch timezone information by name or by abbreviations. This is designed
  4 |   to power parsing strings with timezone abbreviations and offsets in them.
  5 |   """
  6 | 
  7 |   # credo:disable-for-this-file Credo.Check.Refactor.Nesting
  8 | 
  9 |   @beginning_at Application.compile_env(
 10 |                   :date_time_parser,
 11 |                   :include_zones_from,
 12 |                   ~N[2020-01-01 00:00:00]
 13 |                 )
 14 |   {zones, rules} = DateTimeParser.TimezoneParser.parse()
 15 | 
 16 |   @zones Enum.filter(zones, fn zone ->
 17 |            is_nil(zone.until) || NaiveDateTime.compare(zone.until, @beginning_at) == :gt
 18 |          end)
 19 | 
 20 |   @rules rules
 21 | 
 22 |   @default_offset_preferences %{
 23 |     "+0000" => "Etc/UTC",
 24 |     "+0100" => "Etc/GMT-1",
 25 |     "+0200" => "Etc/GMT-2",
 26 |     "+0300" => "Etc/GMT-3",
 27 |     "+0400" => "Etc/GMT-4",
 28 |     "+0500" => "Etc/GMT-5",
 29 |     "+0530" => "Asia/Colombo",
 30 |     "+0600" => "Etc/GMT-6",
 31 |     "+0700" => "Etc/GMT-7",
 32 |     "+0800" => "Etc/GMT-8",
 33 |     "+0900" => "Etc/GMT-9",
 34 |     "+0930" => "Australia/Adelaide",
 35 |     "+1000" => "Etc/GMT-10",
 36 |     "+1100" => "Etc/GMT-11",
 37 |     "+1200" => "Etc/GMT-12",
 38 |     "+1300" => "Etc/GMT-13",
 39 |     "+1400" => "Etc/GMT-14",
 40 |     "-0000" => "Etc/UTC",
 41 |     "-0100" => "Etc/GMT+1",
 42 |     "-0200" => "Etc/GMT+2",
 43 |     "-0300" => "Etc/GMT+3",
 44 |     "-0400" => "Etc/GMT+4",
 45 |     "-0500" => "Etc/GMT+5",
 46 |     "-0530" => "America/Belize",
 47 |     "-0600" => "Etc/GMT+6",
 48 |     "-0700" => "Etc/GMT+7",
 49 |     "-0800" => "Etc/GMT+8",
 50 |     "-0900" => "Etc/GMT+9",
 51 |     "-1000" => "Etc/GMT+10",
 52 |     "-1100" => "Etc/GMT+11"
 53 |   }
 54 | 
 55 |   @default_abbreviation_preferences %{
 56 |     # Preferred GMT where possible, then USA, otherwise most populous.
 57 |     "+01/+00" => "Africa/Casablanca",
 58 |     "+02" => "Etc/GMT-2",
 59 |     "+03" => "Etc/GMT-3",
 60 |     "+04" => "Etc/GMT-4",
 61 |     "+04/+05" => "Asia/Baku",
 62 |     "+05" => "Etc/GMT-5",
 63 |     "+06" => "Etc/GMT-6",
 64 |     "+07" => "Etc/GMT-7",
 65 |     "+08" => "Etc/GMT-8",
 66 |     "+08/+09" => "Asia/Ulaanbaatar",
 67 |     "+09" => "Etc/GMT-9",
 68 |     "+10" => "Etc/GMT-10",
 69 |     "+11" => "Etc/GMT-11",
 70 |     "+1130" => "Pacific/Norfolk",
 71 |     "+11/+12" => "Pacific/Noumea",
 72 |     "+12" => "Etc/GMT-12",
 73 |     "+1215" => "Pacific/Chatham",
 74 |     "+12/+13" => "Pacific/Fiji",
 75 |     "+13" => "Etc/GMT-13",
 76 |     "+13/+14" => "Pacific/Tongatapu",
 77 |     "+14" => "Etc/GMT-14",
 78 |     "-01" => "Etc/GMT+1",
 79 |     "-01/+00" => "Atlantic/Azores",
 80 |     "-02" => "Etc/GMT+2",
 81 |     "-02/-01" => "Europe/Lisbon",
 82 |     "-03" => "Etc/GMT+3",
 83 |     "-03/-02" => "America/Buenos_Aires",
 84 |     "-04" => "Etc/GMT+4",
 85 |     "-0430" => "America/Caracas",
 86 |     "-04/-03" => "America/Santiago",
 87 |     "-05" => "Etc/GMT+5",
 88 |     "-05/-04" => "America/Bogota",
 89 |     "-06/-05" => "Pacific/Galapagos",
 90 |     "-08" => "Etc/GMT+8",
 91 |     "-09" => "Etc/GMT+9",
 92 |     "-10" => "Etc/GMT+10",
 93 |     "-11" => "Etc/GMT+11",
 94 |     # Australia
 95 |     "AWST" => "Australia/Perth",
 96 |     "ACWST" => "Australia/Eucla",
 97 |     "ACT" => "Australia/Adelaide",
 98 |     "ACDT" => "Australia/Adelaide",
 99 |     "ACST" => "Australia/Adelaide",
100 |     "CAST" => "Australia/Adelaide",
101 |     "AET" => "Australia/Sydney",
102 |     "AEST" => "Australia/Sydney",
103 |     "AEDT" => "Australia/Sydney",
104 |     "LHDT" => "Australia/Lord_Howe",
105 |     "NZMT" => "Pacific/Auckland",
106 |     "NZDT" => "Pacific/Auckland",
107 |     "HMT" => "Etc/GMT+5",
108 |     "PMMT" => "Pacific/Bougainville",
109 |     # Americas
110 |     "EMT" => "Pacific/Easter",
111 |     "QMT" => "America/Guayaquil",
112 |     "NDDT" => "Canada/Newfoundland",
113 |     "NWT" => "Canada/Newfoundland",
114 |     "ADT" => "America/Halifax",
115 |     "AWT" => "America/Halifax",
116 |     "ADDT" => "America/Goose_Bay",
117 |     "PPMT" => "America/Port-au-Prince",
118 |     "ALASKA" => "America/New_York",
119 |     "AST" => "Canada/Atlantic",
120 |     "APT" => "Canada/Atlantic",
121 |     "YDT" => "Canada/Yukon",
122 |     "YST" => "Canada/Yukon",
123 |     "YDDT" => "Canada/Yukon",
124 |     "CHST" => "Pacific/Guam",
125 |     "AHST" => "America/Anchorage",
126 |     "AHDT" => "America/Anchorage",
127 |     "YWT" => "Canada/Yukon",
128 |     "YPT" => "Canada/Yukon",
129 |     "AKDT" => "America/Anchorage",
130 |     "AKST" => "America/Anchorage",
131 |     "CENTRAL" => "America/Chicago",
132 |     "CDT" => "America/Chicago",
133 |     "SJMT" => "America/Costa_Rica",
134 |     "CST" => "America/Chicago",
135 |     "CT" => "America/Chicago",
136 |     "CWT" => "America/Belize",
137 |     "CPT" => "America/Belize",
138 |     "CMT" => "America/Buenos_Aires",
139 |     "EASTERN" => "America/New_York",
140 |     "EDT" => "America/New_York",
141 |     "EST" => "America/New_York",
142 |     "ET" => "America/New_York",
143 |     "HAWAII" => "America/New_York",
144 |     "HST" => "Pacific/Honolulu",
145 |     "HPT" => "Pacific/Honolulu",
146 |     "HAT" => "Pacific/Honolulu",
147 |     "HADT" => "Pacific/Honolulu",
148 |     "HAST" => "Pacific/Honolulu",
149 |     "HWT" => "Pacific/Honolulu",
150 |     "MOUNTAIN" => "America/New_York",
151 |     "MDT" => "America/Denver",
152 |     "MST" => "America/Denver",
153 |     "MT" => "America/Denver",
154 |     "PACIFIC" => "America/New_York",
155 |     "PDT" => "America/Los_Angeles",
156 |     "PST" => "America/Los_Angeles",
157 |     "SDMT" => "America/Santo_Domingo",
158 |     "PT" => "America/Los_Angeles",
159 |     "FFMT" => "America/Martinique",
160 |     # Europe
161 |     "BT/BST" => "Europe/London",
162 |     "BMT/BST" => "Europe/London",
163 |     "GMT/BST" => "Europe/London",
164 |     "WMT" => "Europe/Warsaw",
165 |     "AMT" => "Asia/Yerevan",
166 |     "PMT" => "Europe/Paris",
167 |     "LST" => "Europe/Riga",
168 |     "BMT" => "Europe/London",
169 |     "BST" => "Europe/London",
170 |     "BDST" => "Europe/London",
171 |     "BT" => "Europe/London",
172 |     "DMT" => "Europe/Dublin",
173 |     "RMT" => "Europe/Rome",
174 |     "IMT" => "Europe/Istanbul",
175 |     "CET/CEST" => "CET",
176 |     "CEST" => "CET",
177 |     "CEMT" => "Europe/Berlin",
178 |     "CET" => "CET",
179 |     "EET/EEST" => "EET",
180 |     "EEST" => "EET",
181 |     "EET" => "EET",
182 |     "WET/WEST" => "WET",
183 |     "WEST" => "WET",
184 |     "WET" => "WET",
185 |     "WEMT" => "WET",
186 |     "GMT" => "Etc/UTC",
187 |     "GMT/IST" => "Etc/UTC",
188 |     # Africa
189 |     "WAT" => "Africa/Lagos",
190 |     "WAST" => "Africa/Lagos",
191 |     "CAT" => "Africa/Maputo",
192 |     # Asia
193 |     "JMT" => "Asia/Jerusalem",
194 |     "MMT" => "Asia/Yangon",
195 |     "NPT" => "Asia/Katmandu",
196 |     "PLMT" => "Asia/Ho_Chi_Minh",
197 |     "MSK/MSD" => "Europe/Moscow",
198 |     "FMT" => "Atlantic/Madeira",
199 |     "MSDT" => "Europe/Moscow",
200 |     "MDST" => "Europe/Moscow",
201 |     "MSK" => "Europe/Moscow",
202 |     "MSD" => "Europe/Moscow",
203 |     "GST" => "Asia/Dubai",
204 |     "IST" => "Asia/Kolkata",
205 |     "KST" => "Asia/Seoul",
206 |     "WIB" => "Asia/Jakarta",
207 |     "TBMT" => "Asia/Tbilisi",
208 |     "HKT" => "Asia/Hong_Kong",
209 |     "HKWT" => "Asia/Hong_Kong"
210 |   }
211 | 
212 |   def rules, do: @rules
213 |   def zones, do: @zones
214 | 
215 |   def zones(%NaiveDateTime{} = ndt) do
216 |     Enum.filter(zones(), fn zone -> within_rule_timespan(zone.from, zone.until, ndt) end)
217 |   end
218 | 
219 |   def rules_by_name(name), do: Enum.filter(rules(), &(&1.name == name))
220 | 
221 |   def zones_by_name(name, opts \\ []) do
222 |     date = Keyword.get(opts, :at, NaiveDateTime.utc_now())
223 | 
224 |     Enum.filter(zones(), fn candidate_zone ->
225 |       (candidate_zone.name == name or name in candidate_zone.aliases) &&
226 |         within_rule_timespan(candidate_zone.from, candidate_zone.until, date)
227 |     end)
228 |   end
229 | 
230 |   def zones_by_offset(offset, opts \\ [])
231 | 
232 |   def zones_by_offset(offset, opts) do
233 |     offset = normalize_offset(offset)
234 |     date = Keyword.get(opts, :at, NaiveDateTime.utc_now())
235 | 
236 |     Enum.filter(zones(), fn candidate_zone ->
237 |       candidate_zone.utc_offset_hrs == offset &&
238 |         within_rule_timespan(candidate_zone.from, candidate_zone.until, date)
239 |     end)
240 |   end
241 | 
242 |   def zone_by_offset(offset, opts \\ [])
243 | 
244 |   def zone_by_offset(offset, opts) do
245 |     offset = normalize_offset(offset)
246 | 
247 |     Enum.find_value(
248 |       [
249 |         fn -> zones_by_offset(offset, opts) end,
250 |         fn ->
251 |           offset_preferences =
252 |             Map.merge(@default_offset_preferences, Keyword.get(opts, :assume_tz_offsets, %{}))
253 | 
254 |           zones_by_name(offset_preferences[offset] || offset, opts)
255 |         end
256 |       ],
257 |       fn fun ->
258 |         case fun.() do
259 |           [zone] -> zone
260 |           _ -> false
261 |         end
262 |       end
263 |     )
264 |   end
265 | 
266 |   defp normalize_offset("-" <> offset),
267 |     do: "-" <> String.pad_trailing(String.trim(offset, " "), 4, "0")
268 | 
269 |   defp normalize_offset("+" <> offset),
270 |     do: "+" <> String.pad_trailing(String.trim(offset, " "), 4, "0")
271 | 
272 |   # Antartica/Troll has an abbreviation of +00 which confuses things for UTC
273 |   def all_abbreviations(ndt \\ NaiveDateTime.utc_now()) do
274 |     ndt
275 |     |> zones()
276 |     |> Enum.flat_map(fn zone -> Enum.reject(zone.abbreviations, &(&1 == "+00")) end)
277 |     |> Enum.uniq()
278 |   end
279 | 
280 |   def zone_by_abbreviation(abbreviation, opts \\ [])
281 | 
282 |   def zone_by_abbreviation(abbreviation, opts) do
283 |     Enum.find_value(
284 |       [
285 |         fn -> zones_by_abbreviation(abbreviation, opts) end,
286 |         fn ->
287 |           tz_preferences =
288 |             Map.merge(
289 |               @default_abbreviation_preferences,
290 |               Keyword.get(opts, :assume_tz_abbreviations, %{})
291 |             )
292 | 
293 |           zones_by_name(tz_preferences[abbreviation] || abbreviation, opts)
294 |         end
295 |       ],
296 |       fn fun ->
297 |         case fun.() do
298 |           [zone] -> zone
299 |           _ -> false
300 |         end
301 |       end
302 |     )
303 |   end
304 | 
305 |   def zones_by_abbreviation(abbreviation, opts \\ []) do
306 |     tz_preferences =
307 |       Map.merge(
308 |         @default_abbreviation_preferences,
309 |         Keyword.get(opts, :assume_tz_abbreviations, %{})
310 |       )
311 | 
312 |     date = Keyword.get(opts, :at, NaiveDateTime.utc_now())
313 |     name = tz_preferences[abbreviation]
314 | 
315 |     Enum.filter(zones(), fn candidate_zone ->
316 |       (abbreviation in candidate_zone.abbreviations || candidate_zone.name == name) &&
317 |         within_rule_timespan(candidate_zone.from, candidate_zone.until, date)
318 |     end)
319 |   end
320 | 
321 |   @doc false
322 |   def ambiguous_abbreviations(return \\ :name, date \\ NaiveDateTime.utc_now()) do
323 |     zones()
324 |     |> Enum.reduce(%{}, fn zone, acc ->
325 |       if within_rule_timespan(zone.from, zone.until, date) do
326 |         Enum.reduce(zone.abbreviations, acc, fn abbr, acc2 ->
327 |           update_in(acc2, [abbr], &[zone | &1 || []])
328 |         end)
329 |       else
330 |         acc
331 |       end
332 |     end)
333 |     |> Enum.map(fn {abbr, zones} ->
334 |       {abbr,
335 |        {
336 |          zones |> Enum.map(& &1.utc_offset_sec) |> Enum.uniq() |> Enum.count() == 1,
337 |          if return == :zone do
338 |            zones
339 |          else
340 |            Enum.map(zones, &Map.get(&1, return))
341 |          end
342 |        }}
343 |     end)
344 |     |> Enum.filter(fn {_abbr, {_, zones}} -> length(zones) > 1 end)
345 |     |> Enum.into(%{})
346 |   end
347 | 
348 |   @doc false
349 |   def ambiguous_offsets(return \\ :name, date \\ NaiveDateTime.utc_now()) do
350 |     zones()
351 |     |> Enum.reduce(%{}, fn zone, acc ->
352 |       if within_rule_timespan(zone.from, zone.until, date) do
353 |         update_in(acc, [zone.utc_offset_hrs], &[zone | &1 || []])
354 |       else
355 |         acc
356 |       end
357 |     end)
358 |     |> Enum.map(fn {abbr, zones} ->
359 |       {abbr,
360 |        if return == :zone do
361 |          zones
362 |        else
363 |          Enum.map(zones, &Map.get(&1, return))
364 |        end}
365 |     end)
366 |     |> Enum.filter(fn {_abbr, zones} -> length(zones) > 1 end)
367 |     |> Enum.into(%{})
368 |   end
369 | 
370 |   defp within_rule_timespan(from, until, date) do
371 |     case {from, until} do
372 |       {nil, nil} ->
373 |         true
374 | 
375 |       {nil, until} ->
376 |         NaiveDateTime.compare(until, date) == :gt
377 | 
378 |       {from, nil} ->
379 |         NaiveDateTime.compare(from, date) == :lt
380 | 
381 |       {from, until} ->
382 |         NaiveDateTime.compare(from, date) == :lt &&
383 |           NaiveDateTime.compare(until, date) == :gt
384 |     end
385 |   end
386 | 
387 |   @doc """
388 |   Default offsets
389 | 
390 |   ```
391 |   #{inspect(@default_offset_preferences, pretty: true, limit: :infinity)}
392 |   ```
393 |   """
394 |   def default_offsets, do: @default_offset_preferences
395 | 
396 |   @doc """
397 |   Default abbreviations
398 | 
399 |   ```
400 |   #{inspect(@default_abbreviation_preferences, pretty: true, limit: :infinity)}
401 |   ```
402 |   """
403 |   def default_abbreviations, do: @default_abbreviation_preferences
404 | end
405 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # DateTimeParser
  2 | 
  3 | [![Hex.pm Version](http://img.shields.io/hexpm/v/date_time_parser.svg)](https://hex.pm/packages/date_time_parser)
  4 | [![Hex docs](http://img.shields.io/badge/hex.pm-docs-blue.svg?style=flat)](https://hexdocs.pm/date_time_parser)
  5 | [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE.md)
  6 | [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v1.4%20adopted-ff69b4.svg)](./CODE_OF_CONDUCT.md)
  7 | 
  8 | DateTimeParser is a tokenizer for strings that attempts to parse into a
  9 | DateTime, NaiveDateTime if timezone is not determined, Date, or Time.
 10 | 
 11 | You're currently looking at the main branch. [Check out the docs for the latest
 12 | published version.](https://hexdocs.pm/date_time_parser)
 13 | 
 14 | ## Documentation
 15 | 
 16 | [See examples automatically generated by the tests](./EXAMPLES.md)
 17 | 
 18 | <!-- MDOC -->
 19 | 
 20 | The biggest ambiguity between datetime formats is whether it's `ymd` (year month
 21 | day), `mdy` (month day year), or `dmy` (day month year); this is resolved by
 22 | checking if there are slashes or dashes. If slashes, then it will try `dmy`
 23 | first. All other cases will use the international format `ymd`. Sometimes, if
 24 | the conditions are right, it can even parse `dmy` with dashes if the month is a
 25 | vocal month (eg, `"Jan"`).
 26 | 
 27 | If the string consists of only numbers, then we will try two other parsers
 28 | depending on the number of digits: [Epoch] or [Serial]. Otherwise, we'll try the
 29 | tokenizer.
 30 | 
 31 | If the string is 10-11 digits with optional precision, then we'll try to parse
 32 | it as a Unix [Epoch] timestamp.
 33 | 
 34 | If the string is 1-5 digits with optional precision, then we'll try to parse it
 35 | as a [Serial] timestamp (spreadsheet time) treating 1899-12-31 as 1. This will
 36 | cause Excel-produced dates from 1900-01-01 until 1900-03-01 to be incorrect, as
 37 | they really are.
 38 | 
 39 | |digits|parser|range|notes|
 40 | |---|----|---|---|
 41 | |1-5|Serial|low = `1900-01-01`, high = `2173-10-15`. Negative numbers go to `1626-03-17`|Floats indicate time. Integers do not.|
 42 | |6-9|Tokenizer|any|This allows for "20190429" to be parsed as `2019-04-29`|
 43 | |10-11|Epoch|low = `-1100-02-15 14:13:21`, high = `5138-11-16 09:46:39`|If padded with 0s, then it can capture entire range.|
 44 | |else|Tokenizer|any| |
 45 | 
 46 | [Epoch]: https://en.wikipedia.org/wiki/Unix_time
 47 | [Serial]: https://support.office.com/en-us/article/date-systems-in-excel-e7fe7167-48a9-4b96-bb53-5612a800b487
 48 | 
 49 | ## Required reading
 50 | 
 51 | * [Elixir DateTime docs](https://hexdocs.pm/elixir/DateTime.html)
 52 | * [Elixir NaiveDateTime docs](https://hexdocs.pm/elixir/NaiveDateTime.html)
 53 | * [Elixir Date docs](https://hexdocs.pm/elixir/Date.html)
 54 | * [Elixir Time docs](https://hexdocs.pm/elixir/Time.html)
 55 | * [Elixir Calendar docs](https://hexdocs.pm/elixir/Calendar.html)
 56 | 
 57 | ## Examples
 58 | 
 59 | ```elixir
 60 | iex> DateTimeParser.parse("19 September 2018 08:15:22 AM")
 61 | {:ok, ~N[2018-09-19 08:15:22]}
 62 | 
 63 | iex> DateTimeParser.parse_datetime("19 September 2018 08:15:22 AM")
 64 | {:ok, ~N[2018-09-19 08:15:22]}
 65 | 
 66 | iex> DateTimeParser.parse_datetime("2034-01-13", assume_time: true)
 67 | {:ok, ~N[2034-01-13 00:00:00]}
 68 | 
 69 | iex> DateTimeParser.parse_datetime("2034-01-13", assume_time: ~T[06:00:00])
 70 | {:ok, ~N[2034-01-13 06:00:00]}
 71 | 
 72 | iex> DateTimeParser.parse("invalid date 10:30pm")
 73 | {:ok, ~T[22:30:00]}
 74 | 
 75 | iex> DateTimeParser.parse("2019-03-11T99:99:99")
 76 | {:ok, ~D[2019-03-11]}
 77 | 
 78 | iex> DateTimeParser.parse("2019-03-11T10:30:00pm UNK")
 79 | {:ok, ~N[2019-03-11T22:30:00]}
 80 | 
 81 | iex> DateTimeParser.parse("2019-03-11T22:30:00.234+00:00")
 82 | {:ok, DateTime.from_naive!(~N[2019-03-11T22:30:00.234Z], "Etc/UTC")}
 83 | # `~U[2019-03-11T22:30:00.234Z]` in Elixir 1.9+
 84 | 
 85 | iex> DateTimeParser.parse_date("2034-01-13")
 86 | {:ok, ~D[2034-01-13]}
 87 | 
 88 | iex> DateTimeParser.parse_date("01/01.3.07")
 89 | {:ok, ~D[2017-01-01]}
 90 | 
 91 | iex> DateTimeParser.parse_datetime("1564154204")
 92 | {:ok, DateTime.from_naive!(~N[2019-07-26T15:16:44Z], "Etc/UTC")}
 93 | # `~U[2019-07-26T15:16:44Z]` in Elixir 1.9+
 94 | 
 95 | iex> DateTimeParser.parse_datetime("41261.6013888889")
 96 | {:ok, ~N[2012-12-18T14:26:00]}
 97 | 
 98 | iex> DateTimeParser.parse_date("44262")
 99 | {:ok, ~D[2021-03-07]}
100 | # This is a serial number date, commonly found in spreadsheets, eg: `=VALUE("03/07/2021")`
101 | 
102 | iex> DateTimeParser.parse_datetime("1/1/18 3:24 PM")
103 | {:ok, ~N[2018-01-01T15:24:00]}
104 | 
105 | iex> DateTimeParser.parse_datetime("1/1/18 3:24 PM", assume_utc: true)
106 | {:ok, DateTime.from_naive!(~N[2018-01-01T15:24:00Z], "Etc/UTC")}
107 | # `~U[2018-01-01T15:24:00Z]` in Elixir 1.9+
108 | 
109 | iex> DateTimeParser.parse_datetime(~s|"Mar 28, 2018 7:39:53 AM PDT"|, to_utc: true)
110 | {:ok, DateTime.from_naive!(~N[2018-03-28T14:39:53Z], "Etc/UTC")}
111 | 
112 | iex> {:ok, datetime} = DateTimeParser.parse_datetime(~s|"Mar 1, 2018 7:39:53 AM PST"|)
113 | iex> datetime
114 | #DateTime<2018-03-01 07:39:53-08:00 PST America/Los_Angeles>
115 | 
116 | iex> DateTimeParser.parse_datetime(~s|"Mar 1, 2018 7:39:53 AM PST"|, to_utc: true)
117 | {:ok, DateTime.from_naive!(~N[2018-03-01T15:39:53Z], "Etc/UTC")}
118 | 
119 | iex> {:ok, datetime} = DateTimeParser.parse_datetime(~s|"Mar 28, 2018 7:39:53 AM PDT"|)
120 | iex> datetime
121 | #DateTime<2018-03-28 07:39:53-07:00 PDT America/Los_Angeles>
122 | 
123 | iex> DateTimeParser.parse_time("10:13pm")
124 | {:ok, ~T[22:13:00]}
125 | 
126 | iex> DateTimeParser.parse_time("10:13:34")
127 | {:ok, ~T[10:13:34]}
128 | 
129 | iex> DateTimeParser.parse_time("18:14:21.2.0851000000Z")
130 | {:ok, ~T[18:14:21.2]}
131 | 
132 | iex> DateTimeParser.parse_datetime(nil)
133 | {:error, "Could not parse nil"}
134 | ```
135 | 
136 | ## Installation
137 | 
138 | Add `date_time_parser` to your list of dependencies in `mix.exs`:
139 | 
140 | ```elixir
141 | def deps do
142 |   [
143 |     {:date_time_parser, "~> 1.3.0"}
144 |   ]
145 | end
146 | ```
147 | 
148 | ## Configuration
149 | 
150 | You must have a timezone database configured if you want parsing to consider
151 | timezones. See [tz](https://github.com/mathieuprog/tz) or [tzdata](https://github.com/lau/tzdata).
152 | 
153 | ```elixir
154 | # This is the default config
155 | alias DateTimeParser.Parser
156 | config :date_time_parser, parsers: [Parser.Epoch, Parser.Serial, Parser.Tokenizer]
157 | 
158 | # To enable only specific parsers, include them in the :parsers key.
159 | config :date_time_parser, parsers: [Parser.Tokenizer]
160 | 
161 | # To consider more timezones from the past at a performance cost:
162 | config :date_time_parser, include_zones_from: ~N[1900-01-01T00:00:00]
163 | # default is 2020-01-01T00:00:00
164 | 
165 | # Adding the timezone database from Tz
166 | config :elixir, :time_zone_database, Tz.TimeZoneDatabase
167 | 
168 | # Or in runtime, pass in the parsers in the function.
169 | DateTimeParser.parse(mystring, parsers: [Parser.Tokenizer])
170 | ```
171 | 
172 | ## Write your own parser
173 | 
174 | You can write your own parser!
175 | 
176 | If the built-in parsers are not applicable for your use-case, you may build your
177 | own parser to use with this library. Let's write a simple one together.
178 | 
179 | First I will check `DateTimeParser.Parser` to see what behaviour my new parser
180 | should implement. It needs two functions:
181 | 
182 | 1. `c:DateTimeParser.Parser.preflight/1`
183 | 1. `c:DateTimeParser.Parser.parse/1`
184 | 
185 | These functions accept the `t:DateTimeParser.Parser.t/0` struct which contains the
186 | options supplied by the user, the string itself, and the context for which you
187 | should return your result. For example, if the context is `:time` then you should
188 | return a `%Time{}`; if `:datetime` you should return either a
189 | `%NaiveDateTime{}` or a `%DateTime{}`; if `:date` then you should return a
190 | `%Date{}`.
191 | 
192 | Let's implement a parser that reads a special time string. Our string will
193 | represent time, but all the digits are shifted up by 10 and must be prefixed
194 | with the secret word: `"boomshakalaka:"`. For example, the real world time of
195 | `01:10` is represented as `boomshakalaka:11:20` in our toy time format. `12:30`
196 | is represented as `boomshakalaka:22:40`, and `5:55` is represented as
197 | `boomshakalaka:15:65`.
198 | 
199 | ```elixir
200 | defmodule MyParser do
201 |   @behaviour DateTimeParser.Parser
202 |   @secret_regex ~r|boomshakalaka:(?<time>\d{2}:\d{2})|
203 | 
204 |   def preflight(%{string: string} = parser) do
205 |     case Regex.named_captures(@secret_regex, string) do
206 |       %{"time" => time} ->
207 |         {:ok, %{parser | preflight: time}}
208 | 
209 |       nil ->
210 |         {:error, :not_compatible}
211 |     end
212 |   end
213 | 
214 |   # ... more below
215 | end
216 | ```
217 | 
218 | We'll stop here first and go through the preflight function. Our special parser
219 | will only be attempted if the supplied string has any named captures from the
220 | regex. That is, it must begin with `bookshakalaka:` followed by 2 digits, a
221 | colon, and 2 more digits. These digits are extracted out like `00:00` where 0 is
222 | any digit. If `05:40` is passed in, it would not be compatible so the parser
223 | will be skipped.
224 | 
225 | Now let's parse the time:
226 | 
227 | ```elixir
228 | def parse(%{preflight: time} = parser) do
229 |   [hour, minute] = String.split(time, ":")
230 |   {hour, ""} = Integer.parse(hour)
231 |   {minute, ""} = Integer.parse(minute)
232 |   result = Time.new(hour - 10, minute - 10, 0, {0, 0})
233 |   for_context(parser.context, result)
234 | end
235 | 
236 | defp for_context(:datetime, _result), do: :error
237 | defp for_context(:date, _result), do: :error
238 | defp for_context(:time, result), do: result
239 | ```
240 | 
241 | Notice that we need to consider context of the result. If the user asked for a
242 | DateTime, then we need to give them one. In our toy format, it only represents
243 | time, so therefore we must return an error when the context is a `:datetime` or
244 | `:date`.
245 | 
246 | ```elixir
247 | DateTimeParser.parse_time("boomshakalaka:11:11", parsers: [MyParser])
248 | #=> {:ok, ~T[01:01:00]}
249 | 
250 | DateTimeParser.parse_date("boomshakalaka:11:11", parsers: [MyParser])
251 | #=> {:error, "Could not parse \"boomshakalaka:11:11\""}
252 | 
253 | DateTimeParser.parse_datetime("boomshakalaka:11:11", parsers: [MyParser])
254 | #=> {:error, "Could not parse \"boomshakalaka:11:11\""}
255 | 
256 | DateTimeParser.parse("boomshakalaka:11:11", parsers: [MyParser])
257 | #=> {:ok, ~T[01:01:00]}
258 | 
259 | ```
260 | 
261 | ## Why aren't timezones recognized?
262 | 
263 | You might not have a timezone database configured.
264 | 
265 | You may configure one by using [tz](https://github.com/mathieuprog/tz) or
266 | [tzdata](https://github.com/lau/tzdata). Not only should you install it, but
267 | you also must configure Elixir to use it.
268 | 
269 | For example, in a script:
270 | 
271 | ```elixir
272 | Mix.install([:date_time_parser, :tz])
273 | # :ok
274 | DateTimeParser.parse("2020-02-02 10:00:00 PST")
275 | # {:ok, ~N[2020-02-02 10:00:00]}
276 | Application.put_env(:elixir, :time_zone_database, Tz.TimeZoneDatabase)
277 | # :ok
278 | DateTimeParser.parse("2020-02-02 10:00:00 PST")
279 | # {:ok, #DateTime<2020-02-02 10:00:00-08:00 PST America/Los_Angeles>}
280 | ```
281 | 
282 | or in a Mix project:
283 | 
284 | ```elixir
285 | # in mix.exs
286 | defp deps do
287 |   [
288 |     {:date_time_parser, "1.2"},
289 |     {:tz, "~> 0.24"},
290 |   ]
291 | end
292 | 
293 | # in config/config.exs
294 | config :elixir, :time_zone_database, Tz.TimeZoneDatabase
295 | 
296 | # then in code
297 | DateTimeParser.parse("2020-02-02 10:00:00 PST")
298 | #> {:ok, #DateTime<2020-02-02 10:00:00-08:00 PST America/Los_Angeles>}
299 | ```
300 | 
301 | ## Should I use this library?
302 | 
303 | Only as a last resort. Parsing dates from strings is educated guessing at best.
304 | Since Elixir natively supports [ISO-8601] parsing (see `from_iso8601/2`
305 | functions), it's highly recommended that you rely on that first and foremost.
306 | 
307 | When designing your API that involves dates and strings, be specific with your
308 | requirements and supported DateTime strings, and preferably only support
309 | [ISO-8601] with no exceptions. There is _no_ ambiguity with this format so
310 | parsing to DateTime (or Date or Time) will always be correct.
311 | 
312 | This library is helpful when you _must_ accept ambiguous DateTime string formats
313 | and having incorrect results is acceptable. Do not use this library when the
314 | resulting (and possibly incorrect) DateTime has catastrophic and dangerous
315 | effects in your system.
316 | 
317 | [ISO-8601]: https://en.wikipedia.org/wiki/ISO_8601
318 | 
319 | <!-- MDOC -->
320 | 
321 | ## How to store future timestamps
322 | 
323 | [see guide](./pages/Future-UTC-DateTime.md)
324 | 
325 | tldr: rules change, so don't convert to UTC too early. The future might change
326 | the timezone conversion rules.
327 | 
328 | ## Changelog
329 | 
330 | [View Changelog](./CHANGELOG.md)
331 | 
332 | ## Upgrading from 0.x to 1.0
333 | 
334 | * If you use `parse_datetime/1`, then change to `parse_datetime/2` with the
335 |   second argument as a keyword list to `assume_time: true` and `to_utc: true`.
336 |   In 0.x, it would merge `~T[00:00:00]` if the time tokens could not be parsed;
337 |   in 1.x, you have to opt into this behavior. Also in 0.x, a non-UTC timezone
338 |   would automatically convert to UTC; in 1.x, the original timezone will be
339 |   kept instead.
340 | * If you use `parse_date/1`, then change to `parse_date/2` with the second
341 |   argument as a keyword list to `assume_date: true`. In 0.x, it would merge
342 |   `Date.utc_today()` with the found date tokens; in 1.x, you need to opt into
343 |   this behavior.
344 | * If you use `parse_time`, there is no breaking change but parsing has been
345 |   improved.
346 | * Not a breaking change, but 1.x introduces `parse/2` that will return the best
347 |   struct from the tokens. This may influence your usage.
348 | 
349 | ## Contributing
350 | 
351 | [How to contribute](./CONTRIBUTING.md)
352 | 
353 | ## Special Thanks
354 | 
355 | https://www.taxjar.com
356 | 


--------------------------------------------------------------------------------
/EXAMPLES.livemd:
--------------------------------------------------------------------------------
  1 | # DateTimeParser Playground
  2 | 
  3 | ## Installation
  4 | 
  5 | Install DateTimeParser in your project
  6 | 
  7 | ```elixir
  8 | Mix.install([:date_time_parser, :tz])
  9 | Application.put_env(:elixir, :time_zone_database, Tz.TimeZoneDatabase)
 10 | ```
 11 | 
 12 | ## Usage
 13 | 
 14 | Use DateTimeParser to parse strings into DateTime, NaiveDateTime, Date, or Time
 15 | structs. For example:
 16 | 
 17 | ```elixir
 18 | [
 19 |   DateTimeParser.parse_datetime("2021-11-09T10:30:00Z"),
 20 |   DateTimeParser.parse_datetime("2021-11-09T10:30:00"),
 21 |   DateTimeParser.parse_date("2021-11-09T10:30:00Z"),
 22 |   DateTimeParser.parse_time("2021-11-09T10:30:00Z"),
 23 |   DateTimeParser.parse("2021-32-32T10:30:00Z"),
 24 |   DateTimeParser.parse("2021-11-09T10:30:00Z"),
 25 |   DateTimeParser.parse("2021-11-09T10:30:00 EST")
 26 | ]
 27 | ```
 28 | 
 29 | or use the bang functions:
 30 | 
 31 | ```elixir
 32 | [
 33 |   DateTimeParser.parse_datetime!("2021-11-09T10:30:00Z"),
 34 |   DateTimeParser.parse_datetime!("2021-11-09T10:30:00"),
 35 |   DateTimeParser.parse_date!("2021-11-09T10:30:00Z"),
 36 |   DateTimeParser.parse_time!("2021-11-09T10:30:00Z"),
 37 |   DateTimeParser.parse!("2021-32-32T10:30:00Z"),
 38 |   DateTimeParser.parse!("2021-11-09T10:30:00Z"),
 39 |   DateTimeParser.parse!("2021-11-09T10:30:00 EST")
 40 | ]
 41 | ```
 42 | 
 43 | Errors sometimes occur when it can't parse the input:
 44 | 
 45 | ```elixir
 46 | [
 47 |   DateTimeParser.parse("wat"),
 48 |   DateTimeParser.parse(123),
 49 |   DateTimeParser.parse([:foo])
 50 | ]
 51 | ```
 52 | 
 53 | ## Options
 54 | 
 55 | You can configure some convenient options as well, for example to automatically
 56 | convert to UTC or to assume a time when not present.
 57 | 
 58 | ```elixir
 59 | [
 60 |   DateTimeParser.parse("12:30PM", assume_date: Date.utc_today()),
 61 |   DateTimeParser.parse("2022-01-01", assume_time: ~T[12:43:00]),
 62 |   DateTimeParser.parse("2022-01-01T15:30 EST", to_utc: true),
 63 |   DateTimeParser.parse("2022-01-01T15:30 EST", to_utc: false),
 64 |   # Excel time
 65 |   DateTimeParser.parse("30134"),
 66 |   # old Mac Excel spreadsheet time
 67 |   DateTimeParser.parse("30134.4321", use_1904_date_system: true)
 68 | ]
 69 | ```
 70 | 
 71 | ## Examples
 72 | 
 73 | |**Input**|**Output (ISO 8601)**|**Method**|**Options**|
 74 | |:-------:|:-------------------:|:--------:|:---------:|
 75 | |` 01 Feb 2013`|`2013-02-01`|parse| |
 76 | |` 03 Jan 2013 10:15:26 -0800`|`2013-01-03T18:15:26Z`|parse|`[to_utc: true]`|
 77 | |` 10/1/2018  :: AM`|`2018-10-01`|parse| |
 78 | |` 11 Feb 2013`|`2013-02-11`|parse| |
 79 | |` 11 Jan 2013 13:26:55 -0800`|`2013-01-11T21:26:55Z`|parse|`[to_utc: true]`|
 80 | |` 12/26/2016`|`2016-12-26`|parse| |
 81 | |` 24 Sep 2013`|`2013-09-24`|parse| |
 82 | |`""=""9/5/2018"""`|`2018-09-05`|parse_date| |
 83 | |`""=""9/5/2018"""`|`2018-09-05T00:00:00`|parse_datetime|`[assume_time: true]`|
 84 | |`"=""10/1/2018"""`|`2018-10-01`|parse| |
 85 | |`"=""9/5/2018"""`|`2018-09-05`|parse| |
 86 | |`"Apr 1, 2016 12:02:53 AM PDT"`|`2016-04-01T07:02:53Z`|parse|`[to_utc: true]`|
 87 | |`"Apr 1, 2017 2:21:25 AM PDT"`|`2017-04-01T09:21:25Z`|parse|`[to_utc: true]`|
 88 | |`"Dec 1, 2018 7:39:53 AM PST"`|`2018-12-01T15:39:53Z`|parse|`[to_utc: true]`|
 89 | |`"Jan 1, 2013 06:34:31 PM PST"`|`2013-01-02T02:34:31Z`|parse|`[to_utc: true]`|
 90 | |`"Jan 1, 2014 6:44:47 AM PST"`|`2014-01-01T14:44:47Z`|parse|`[to_utc: true]`|
 91 | |`"Mar 28, 2014 6:44:47 AM PDT"`|`2014-03-28T13:44:47Z`|parse|`[to_utc: true]`|
 92 | |`"Nov 16, 2017 9:41:28 PM PST"`|`2017-11-17T05:41:28Z`|parse|`[to_utc: true]`|
 93 | |`"Nov 20, 2016 22:09:23 PM"`|`2016-11-20T22:09:23`|parse| |
 94 | |`"Sat, 29 Sep 2018 21:36:28 -0400"`|`2018-09-30T01:36:28Z`|parse|`[to_utc: true]`|
 95 | |`"September 28, 2016"`|`2016-09-28`|parse| |
 96 | |`"Tuesday, November 29, 2016"`|`2016-11-29`|parse| |
 97 | |`-0000000001`|`1969-12-31`|parse_date| |
 98 | |`-0000000001`|`1969-12-31T23:59:59Z`|parse_datetime| |
 99 | |`-0000000001.0000000001`|`23:59:58.000000`|parse_time| |
100 | |`-0000000001.0000000001`|`1969-12-31T23:59:58.000000Z`|parse_datetime| |
101 | |`-0000000001.000001`|`23:59:58.999999`|parse_time| |
102 | |`-0000000001.00001`|`23:59:58.99999`|parse_time| |
103 | |`-0000000001.0001`|`23:59:58.9999`|parse_time| |
104 | |`-0000000001.001`|`1969-12-31`|parse_date| |
105 | |`-0000000001.001`|`23:59:58.999`|parse_time| |
106 | |`-0000000001.01`|`23:59:58.99`|parse_time| |
107 | |`-0000000001.1`|`23:59:58.9`|parse_time| |
108 | |`-0000000001.111111`|`1969-12-31`|parse_date| |
109 | |`-0386380800`|`1957-10-04T00:00:00Z`|parse_datetime| |
110 | |`-363`|`1899-01-01`|parse_date| |
111 | |`-363.0`|`1899-01-01T00:00:00`|parse_datetime| |
112 | |`-45103.1454398148`|`1776-07-04`|parse_date| |
113 | |`-45103.1454398148`|`20:30:34`|parse_time| |
114 | |`-45103.1454398148`|`1776-07-04T20:30:34`|parse_datetime| |
115 | |`-9999999999`|`1653-02-10T06:13:21Z`|parse_datetime| |
116 | |`-9999999999.009`|`1653-02-10`|parse_date| |
117 | |`-9999999999.9`|`06:13:20.1`|parse_time| |
118 | |`-9999999999.99`|`06:13:20.01`|parse_time| |
119 | |`-9999999999.999`|`1653-02-10`|parse_date| |
120 | |`-9999999999.999`|`06:13:20.001`|parse_time| |
121 | |`-9999999999.9999`|`06:13:20.0001`|parse_time| |
122 | |`-9999999999.99999`|`06:13:20.00001`|parse_time| |
123 | |`-9999999999.999999`|`1653-02-10`|parse_date| |
124 | |`-9999999999.999999`|`06:13:20.000001`|parse_time| |
125 | |`-9999999999.9999999999`|`1653-02-10`|parse_date| |
126 | |`-9999999999.9999999999`|`06:13:20.000001`|parse_time| |
127 | |`-9999999999.9999999999`|`1653-02-10T06:13:20.000001Z`|parse_datetime| |
128 | |`-99999999999`|`-1199-02-15T14:13:21Z`|parse_datetime| |
129 | |`0000000000`|`1970-01-01`|parse_date| |
130 | |`0000000000`|`00:00:00`|parse_time| |
131 | |`0000000000`|`1970-01-01T00:00:00Z`|parse_datetime| |
132 | |`00:00.0`|`00:00:00`|parse_time| |
133 | |`01-01-2018`|`2018-01-01`|parse| |
134 | |`01-Feb-18`|`2018-02-01`|parse| |
135 | |`01-Jul`|`2019-07-01`|parse|`[assume_date: ~D[2019-01-05]]`|
136 | |`01-Jul`|`Could not parse "01-Jul"`|parse| |
137 | |`01-Jul`|`Could not parse "01-Jul"`|parse_datetime| |
138 | |`01-Jul-18`|`2018-07-01`|parse| |
139 | |`01.09.2018`|`2018-09-01`|parse| |
140 | |`01.11.2018`|`2018-11-01`|parse| |
141 | |`01/01/17`|`2017-01-01`|parse| |
142 | |`01/01/2017`|`2017-01-01`|parse| |
143 | |`01/01/2018 - 17:06`|`2018-01-01T17:06:00`|parse| |
144 | |`01/01/2018 01:21PM`|`2018-01-01T13:21:00`|parse| |
145 | |`01/01/2018 14:44`|`2018-01-01T14:44:00`|parse| |
146 | |`01/01/2018 6:22`|`2018-01-01T06:22:00`|parse| |
147 | |`01/02/16`|`2016-01-02`|parse| |
148 | |`01/02/18 01:02 AM`|`2018-01-02T01:02:00`|parse| |
149 | |`01/02/2015`|`2015-01-02`|parse| |
150 | |`01/09/2034`|`2034-01-09`|parse_date| |
151 | |`01/09/2034`|`2034-01-09T00:00:00`|parse_datetime|`[assume_time: true]`|
152 | |`01/Jun./2018`|`2018-06-01`|parse| |
153 | |`02-05-2018`|`2018-05-02`|parse| |
154 | |`02-Oct-17`|`2017-10-02`|parse| |
155 | |`02/01/17`|`2017-02-01`|parse| |
156 | |`02/01/2018`|`2018-02-01`|parse| |
157 | |`02/06/2019`|`2019-02-06`|parse_date| |
158 | |`02/06/2019`|`2019-02-06T00:00:00`|parse_datetime|`[assume_time: true]`|
159 | |`02/21/2018  9:37:42 AM`|`2018-02-21T09:37:42`|parse| |
160 | |`03/5/2018`|`2018-03-05`|parse| |
161 | |`05/01/2018 0:00`|`2018-05-01T00:00:00`|parse| |
162 | |`06/14/2018 09:42:08 PM-0500`|`2018-06-15T02:42:08Z`|parse|`[to_utc: true]`|
163 | |`06/28/18 1:25`|`2018-06-28T01:25:00`|parse| |
164 | |`07:09.3`|`07:09:00`|parse_time| |
165 | |`08:53.0`|`08:53:00`|parse_time| |
166 | |`1-Apr`|`2019-04-01`|parse|`[assume_date: ~D[2019-01-13]]`|
167 | |`1-Apr`|`Could not parse "1-Apr"`|parse| |
168 | |`1//1/17`|`2017-01-01`|parse| |
169 | |`1/1/0117`|`0117-01-01`|parse| |
170 | |`1/1/17 19:12`|`2017-01-01T19:12:00`|parse| |
171 | |`1/1/18 00:01`|`2018-01-01T00:01:00`|parse| |
172 | |`1/1/18 3:24 PM`|`2018-01-01T15:24:00`|parse| |
173 | |`1/1/19 10:39 AM`|`2019-01-01T10:39:00`|parse| |
174 | |`1/1/2013`|`2013-01-01`|parse| |
175 | |`1/10/2018  8:38pM`|`2018-01-10T20:38:00`|parse| |
176 | |`1/13/19`|`2019-01-13`|parse_date| |
177 | |`1/13/19`|`2019-01-13T00:00:00`|parse_datetime|`[assume_time: true]`|
178 | |`1/13/2019`|`2019-01-13`|parse_date| |
179 | |`1/13/2019`|`2019-01-13T00:00:00`|parse_datetime|`[assume_time: true]`|
180 | |`1/15/2019 3:06`|`2019-01-15`|parse_date| |
181 | |`1/15/2019 3:06`|`2019-01-15T03:06:00`|parse_datetime| |
182 | |`1/17/2018 0:00:00`|`2018-01-17T00:00:00`|parse| |
183 | |`1/2/2018 18:06:26`|`2018-01-02T18:06:26`|parse| |
184 | |`1/3/2019 12:00:00 AM`|`2019-01-03T00:00:00`|parse| |
185 | |`1/31/2018 0:00:00 UTC`|`2018-01-31T00:00:00Z`|parse| |
186 | |`1/9/2034`|`2034-01-09`|parse_date| |
187 | |`1/9/2034`|`2034-01-09T00:00:00`|parse_datetime|`[assume_time: true]`|
188 | |`1/9/34`|`2034-01-09`|parse_date| |
189 | |`1/9/34`|`2034-01-09T00:00:00`|parse_datetime|`[assume_time: true]`|
190 | |`10/2/2017 - 23:14`|`2017-10-02T23:14:00`|parse| |
191 | |`10/5/2017 23:52`|`2017-10-05T23:52:00`|parse| |
192 | |`10:13.7`|`10:13:00`|parse_time| |
193 | |`11 July 2017 1:43:46 PM`|`2017-07-11`|parse_date| |
194 | |`11 July 2017 1:43:46 PM`|`2017-07-11T13:43:46`|parse_datetime| |
195 | |`11th July 2017 1:43:46 PM`|`2017-07-11T13:43:46`|parse_datetime| |
196 | |`12/5`|`2021-12-05`|parse_date|`[assume_date: ~D[2021-01-01]]`|
197 | |`12:30PM`|`12:30:00`|parse_time|`[assume_date: ~D[2020-01-01]]`|
198 | |`12:30PM`|`2020-01-01T12:30:00`|parse|`[assume_date: ~D[2020-01-01]]`|
199 | |`12th August 2018 08:15:22`|`2018-08-12T08:15:22`|parse_datetime| |
200 | |`13/5`|`2021-05-13`|parse_date|`[assume_date: ~D[2021-01-01]]`|
201 | |`13th Sep 2019 9:00 AM`|`2019-09-13T09:00:00`|parse_datetime| |
202 | |`14-Jul-2023`|`2023-07-14T00:00:00`|parse_datetime|`[assume_time: true]`|
203 | |`18-07-2018 20:38:34 +00:00`|`2018-07-18T20:38:34Z`|parse| |
204 | |`18-12-29`|`2018-12-29`|parse| |
205 | |`19 September 18 2:33:08 PM`|`2018-09-19`|parse_date| |
206 | |`19 September 18 2:33:08 PM`|`2018-09-19T14:33:08`|parse_datetime| |
207 | |`19 September 2018 08:15:22 AM`|`2018-09-19`|parse_date| |
208 | |`19 September 2018 08:15:22 AM`|`2018-09-19T08:15:22`|parse_datetime| |
209 | |`19-Dec-19`|`2019-12-19`|parse| |
210 | |`1st January 2025`|`2025-01-01`|parse_date| |
211 | |`1st January 2025 09:15:30`|`2025-01-01T09:15:30`|parse_datetime| |
212 | |`2`|`1900-01-01`|parse_date| |
213 | |`2.0`|`1900-01-01T00:00:00`|parse_datetime| |
214 | |`2/5`|`2021-02-05`|parse_date|`[assume_date: ~D[2021-01-01]]`|
215 | |`2010/01/01`|`2010-01-01`|parse| |
216 | |`2011-01-01 04:19:20 -0:00`|`2011-01-01T04:19:20Z`|parse| |
217 | |`2012-10-30 09:52:00`|`2012-10-30T09:52:00`|parse| |
218 | |`2012-11-23T22:42:25-05:00`|`2012-11-24T03:42:25Z`|parse|`[to_utc: true]`|
219 | |`2013-04-26 11:25:03 UTC`|`2013-04-26T11:25:03Z`|parse| |
220 | |`2013-09-10 22:14:56.717`|`2013-09-10T22:14:56.717`|parse| |
221 | |`2013-12-31T22:18:50+00:00`|`2013-12-31T22:18:50Z`|parse| |
222 | |`2015-09-28 10:57:11 -0700`|`2015-09-28T17:57:11Z`|parse|`[to_utc: true]`|
223 | |`2015/12/1 1:16`|`2015-12-01T01:16:00`|parse| |
224 | |`2016-02-29`|`2016-02-29`|parse_date| |
225 | |`2016-02-29 00:00:00 UTC`|`2016-02-29T00:00:00Z`|parse_datetime| |
226 | |`2016-04-30`|`2016-04-30`|parse| |
227 | |`2016-05-02T01:10:06+00:00`|`2016-05-02T01:10:06Z`|parse| |
228 | |`2016-06-11 15:50:43`|`2016-06-11T15:50:43`|parse| |
229 | |`2016-06-16 06:06:06`|`2016-06-16T06:06:06`|parse| |
230 | |`2016-07-01 01:51:34+00`|`2016-07-01T01:51:34Z`|parse| |
231 | |`2016-07-31 18:42:46-07:00`|`2016-08-01T01:42:46Z`|parse|`[to_utc: true]`|
232 | |`2016-08-04T07:00:25Z`|`2016-08-04T07:00:25Z`|parse| |
233 | |`2016-08-19 09:34:51.0`|`2016-08-19T09:34:51.0`|parse| |
234 | |`2016-11-17 10:36:34.81`|`2016-11-17T10:36:34.81`|parse| |
235 | |`2016-11-23T16:25:33.971897`|`2016-11-23T16:25:33.971897`|parse| |
236 | |`2016/1/9`|`2016-01-09`|parse| |
237 | |`2017-02-29`|`Could not parse "2017-02-29"`|parse_date| |
238 | |`2017-02-29 00:00:00 UTC`|`Could not parse "2017-02-29 00:00:00 UTC"`|parse_datetime| |
239 | |`2017-03-04 15:20:47 EDT`|`2017-03-04T20:20:47Z`|parse_datetime|`[to_utc: true]`|
240 | |`2017-03-04 15:20:47 EST`|`2017-03-04T20:20:47Z`|parse_datetime|`[to_utc: true]`|
241 | |`2017-04-31`|`Could not parse "2017-04-31"`|parse_date| |
242 | |`2017-04-31 00:00:00 UTC`|`Could not parse "2017-04-31 00:00:00 UTC"`|parse_datetime| |
243 | |`2017-06-31`|`Could not parse "2017-06-31"`|parse_date| |
244 | |`2017-06-31 00:00:00 UTC`|`Could not parse "2017-06-31 00:00:00 UTC"`|parse_datetime| |
245 | |`2017-09-29+00:00`|`2017-09-29T00:00:00`|parse| |
246 | |`2017-09-31`|`Could not parse "2017-09-31"`|parse_date| |
247 | |`2017-09-31 00:00:00 UTC`|`Could not parse "2017-09-31 00:00:00 UTC"`|parse_datetime| |
248 | |`2017-10-06+03:45:16`|`2017-10-06T03:45:16`|parse| |
249 | |`2017-10-24 04:00:10 PDT`|`2017-10-24T11:00:10Z`|parse|`[to_utc: true]`|
250 | |`2017-11-04 15:20:47 EDT`|`2017-11-04`|parse_date| |
251 | |`2017-11-04 15:20:47 EDT`|`2017-11-04T19:20:47Z`|parse_datetime|`[to_utc: true]`|
252 | |`2017-11-04 15:20:47 EST`|`2017-11-04`|parse_date| |
253 | |`2017-11-04 15:20:47 EST`|`2017-11-04T19:20:47Z`|parse_datetime|`[to_utc: true]`|
254 | |`2017-11-04 15:20:47 UTC`|`2017-11-04`|parse_date| |
255 | |`2017-11-04 15:20:47 UTC`|`2017-11-04T15:20:47Z`|parse_datetime| |
256 | |`2017-11-04 15:20:47+0000`|`2017-11-04`|parse_date| |
257 | |`2017-11-04 15:20:47+0000`|`2017-11-04T15:20:47Z`|parse_datetime| |
258 | |`2017-11-04 15:20:47+0500`|`2017-11-04`|parse_date| |
259 | |`2017-11-04 15:20:47+0500`|`2017-11-04T10:20:47Z`|parse_datetime|`[to_utc: true]`|
260 | |`2017-11-04 15:20:47-0500`|`2017-11-04`|parse_date| |
261 | |`2017-11-04 15:20:47-0500`|`2017-11-04T20:20:47Z`|parse_datetime|`[to_utc: true]`|
262 | |`2017-11-31`|`Could not parse "2017-11-31"`|parse_date| |
263 | |`2017-11-31 00:00:00 UTC`|`Could not parse "2017-11-31 00:00:00 UTC"`|parse_datetime| |
264 | |`2017-12-01 03:52`|`2017-12-01T03:52:00`|parse| |
265 | |`2017/08/08`|`2017-08-08`|parse| |
266 | |`2019-05-16+04:00`|`2019-05-16`|parse_date| |
267 | |`2019-05-16+04:00`|`2019-05-16T04:00:00`|parse_datetime|`[assume_time: true]`|
268 | |`2019-05-20 10:00:00PST`|`2019-05-20`|parse_date| |
269 | |`2019-05-20 10:00:00PST`|`2019-05-20T17:00:00Z`|parse_datetime|`[to_utc: true]`|
270 | |`2019/01/31 0:01`|`2019-01-31T00:01:00`|parse| |
271 | |`2021-03-27 00:00 am`|`2021-03-27T00:00:00`|parse_datetime| |
272 | |`2021-03-27 00:00 pm`|`2021-03-27T00:00:00`|parse_datetime| |
273 | |`2021-03-27 12:00 am`|`2021-03-27T00:00:00`|parse_datetime| |
274 | |`2021-03-27 12:00 pm`|`2021-03-27T12:00:00`|parse_datetime| |
275 | |`2034-01-13`|`2034-01-13`|parse_date| |
276 | |`2034-01-13`|`2034-01-13T00:00:00`|parse_datetime|`[assume_time: true]`|
277 | |`2034-1-9`|`2034-01-09`|parse_date| |
278 | |`2034-1-9`|`2034-01-09T00:00:00`|parse_datetime|`[assume_time: true]`|
279 | |`20340109`|`2034-01-09T00:00:00`|parse_datetime|`[assume_time: true]`|
280 | |`21st April 2022`|`2022-04-21`|parse_date| |
281 | |`21st April 2022`|`2022-04-21T00:00:00`|parse_datetime|`[assume_time: true]`|
282 | |`22nd May 2021`|`2021-05-22`|parse_date| |
283 | |`22nd May 2021 12:00 PM`|`2021-05-22T12:00:00`|parse_datetime| |
284 | |`23-05-2019 @ 10:01`|`2019-05-23`|parse_date| |
285 | |`23-05-2019 @ 10:01`|`2019-05-23T10:01:00`|parse_datetime|`[assume_time: true]`|
286 | |`23rd June 2020`|`2020-06-23`|parse_date| |
287 | |`24:00`|`Could not parse "24:00"`|parse_time| |
288 | |`25th November 2017`|`2017-11-25`|parse_date| |
289 | |`29/Aug./2018`|`2018-08-29`|parse| |
290 | |`29/Sep./2018`|`2018-09-29`|parse| |
291 | |`2nd February 2024`|`2024-02-02`|parse_date| |
292 | |`30134`|`1982-07-02`|parse| |
293 | |`30134.0`|`1982-07-02T00:00:00`|parse| |
294 | |`30th Sept 2016`|`2016-09-30`|parse_date| |
295 | |`31st Dec 2019`|`2019-12-31`|parse_date| |
296 | |`34-1-13`|`2034-01-13`|parse_date| |
297 | |`34-1-13`|`2034-01-13T00:00:00`|parse_datetime|`[assume_time: true]`|
298 | |`3rd March 2023`|`2023-03-03`|parse_date| |
299 | |`4/24/2019 0:00:00`|`2019-04-24`|parse_date| |
300 | |`4/24/2019 0:00:00`|`2019-04-24T00:00:00`|parse_datetime| |
301 | |`41261.6013888889`|`2012-12-18`|parse_date| |
302 | |`41261.6013888889`|`14:26:00`|parse_time| |
303 | |`41261.6013888889`|`2012-12-18T14:26:00`|parse_datetime| |
304 | |`4th Oct 2018`|`2018-10-04`|parse_date| |
305 | |`5/12/2019 12:21:58 PM`|`2019-05-12T12:21:58`|parse| |
306 | |`5/2/2019 0:00:00`|`2019-05-02`|parse_date| |
307 | |`5/2/2019 0:00:00`|`2019-05-02T00:00:00`|parse_datetime| |
308 | |`5/2/2019 12:00:00 AM`|`2019-05-02`|parse_date| |
309 | |`5/2/2019 12:00:00 AM`|`2019-05-02T00:00:00`|parse_datetime| |
310 | |`5/31/2019 12:00:00 AM`|`2019-05-31`|parse_date| |
311 | |`5/31/2019 12:00:00 AM`|`2019-05-31T00:00:00`|parse_datetime| |
312 | |`5th Jan 2025`|`2025-01-05`|parse_date| |
313 | |`5th Jan 2025 10:30:00 AM`|`2025-01-05T10:30:00`|parse_datetime| |
314 | |`62`|`1900-03-02`|parse_date| |
315 | |`62`|`1900-03-02T00:00:00`|parse|`[assume_time: true]`|
316 | |`62`|`1904-03-03T00:00:00`|parse|`[assume_time: true, use_1904_date_system: true]`|
317 | |`62.0`|`1900-03-02T00:00:00`|parse| |
318 | |`62.0`|`1900-03-02T00:00:00`|parse_datetime| |
319 | |`62.0`|`1904-03-03T00:00:00`|parse|`[use_1904_date_system: true]`|
320 | |`62.0`|`1904-03-03T00:00:00`|parse_datetime|`[use_1904_date_system: true]`|
321 | |`9-2-32`|`2032-02-09`|parse_date| |
322 | |`9-2-32`|`2032-02-09T00:00:00`|parse_datetime|`[assume_time: true]`|
323 | |`9-Feb-18`|`2018-02-09`|parse_date| |
324 | |`9-Feb-18`|`2018-02-09T00:00:00`|parse_datetime|`[assume_time: true]`|
325 | |`9/1/2018 10:26`|`2018-09-01`|parse_date| |
326 | |`9/1/2018 10:26`|`2018-09-01T10:26:00`|parse_datetime|`[assume_time: true]`|
327 | |`9/10/2018 11:08:13 AM`|`2018-09-10T11:08:13`|parse| |
328 | |`9/19/2018 20:38`|`2018-09-19T20:38:00`|parse| |
329 | |`9/20/2017 18:57:24 UTC`|`2017-09-20T18:57:24Z`|parse| |
330 | |`9/4/2018 0:00`|`2018-09-04`|parse_date| |
331 | |`9/4/2018 0:00`|`2018-09-04T00:00:00`|parse_datetime| |
332 | |`9999999999`|`2286-11-20`|parse_date| |
333 | |`9999999999`|`17:46:39`|parse_time| |
334 | |`9999999999`|`2286-11-20T17:46:39Z`|parse_datetime| |
335 | |`9999999999.0000000009`|`2286-11-20T17:46:39.000000Z`|parse_datetime| |
336 | |`9999999999.0000009000`|`2286-11-20T17:46:39.000000Z`|parse_datetime| |
337 | |`9999999999.000001`|`17:46:39.000001`|parse_time| |
338 | |`9999999999.000010`|`17:46:39.000010`|parse_time| |
339 | |`9999999999.000100`|`17:46:39.000100`|parse_time| |
340 | |`9999999999.001000`|`17:46:39.001000`|parse_time| |
341 | |`9999999999.009`|`2286-11-20`|parse_date| |
342 | |`9999999999.009`|`17:46:39.009`|parse_time| |
343 | |`9999999999.009`|`2286-11-20T17:46:39.009Z`|parse_datetime| |
344 | |`9999999999.010000`|`17:46:39.010000`|parse_time| |
345 | |`9999999999.090`|`2286-11-20T17:46:39.090Z`|parse_datetime| |
346 | |`9999999999.100000`|`17:46:39.100000`|parse_time| |
347 | |`9999999999.900`|`17:46:39.900`|parse_time| |
348 | |`9999999999.900`|`2286-11-20T17:46:39.900Z`|parse_datetime| |
349 | |`9999999999.999`|`2286-11-20`|parse_date| |
350 | |`9999999999.999`|`17:46:39.999`|parse_time| |
351 | |`9999999999.999`|`2286-11-20T17:46:39.999Z`|parse_datetime| |
352 | |`9999999999.999999`|`2286-11-20`|parse_date| |
353 | |`9999999999.999999`|`17:46:39.999999`|parse_time| |
354 | |`9999999999.999999`|`2286-11-20T17:46:39.999999Z`|parse_datetime| |
355 | |`9999999999.9999999999`|`2286-11-20`|parse_date| |
356 | |`9999999999.9999999999`|`17:46:39.999999`|parse_time| |
357 | |`9999999999.9999999999`|`2286-11-20T17:46:39.999999Z`|parse_datetime| |
358 | |`99999999999`|`5138-11-16`|parse_date| |
359 | |`99999999999`|`09:46:39`|parse_time| |
360 | |`99999999999`|`5138-11-16T09:46:39Z`|parse_datetime| |
361 | |`Fri Mar  2 09:01:57 2018`|`2018-03-02T09:01:57`|parse| |
362 | |`Fri Mar 31 2017 21:41:40 GMT+0000 (UTC)`|`2017-03-31T21:41:40Z`|parse| |
363 | |`Friday 02 February 2018 10:42:21 AM`|`2018-02-02T10:42:21`|parse| |
364 | |`Friday 22nd May 2021`|`2021-05-22`|parse_date| |
365 | |`Jan 2020`|`2020-01-01`|parse_date|`[assume_date: ~D[0001-12-01]]`|
366 | |`Jan-01-19`|`2019-01-01`|parse| |
367 | |`Jan-01-19`|`2019-01-01T00:00:00`|parse|`[assume_time: true]`|
368 | |`Jan-01-19`|`2019-01-01T10:13:15`|parse|`[assume_time: ~T[10:13:15]]`|
369 | |`Jan-01-2018`|`2018-01-01`|parse| |
370 | |`May 1442`|`1442-05-01`|parse_date|`[assume_date: ~D[0001-12-01]]`|
371 | |`May 30, 2019 4:31:09 AM PDT`|`2019-05-30`|parse_date| |
372 | |`May 30, 2019 4:31:09 AM PDT`|`2019-05-30T11:31:09Z`|parse_datetime|`[to_utc: true]`|
373 | |`Monday 01 October 2018 06:34:19 AM`|`2018-10-01T06:34:19`|parse| |
374 | |`Monday 02 October 2017 9:04:49 AM`|`2017-10-02T09:04:49`|parse| |
375 | |`Monday 1st January 2025`|`2025-01-01`|parse_date| |
376 | |`Monday 1st January 2025 09:15:30`|`2025-01-01T09:15:30`|parse_datetime| |
377 | |`November 29, 2016`|`2016-11-29`|parse_date| |
378 | |`November 29, 2016`|`2016-11-29T00:00:00`|parse_datetime|`[assume_time: true]`|
379 | |`Oct 5, 2018 6:16:56 PM PDT`|`2018-10-05`|parse_date| |
380 | |`Oct 5, 2018 6:16:56 PM PDT`|`2018-10-06T01:16:56Z`|parse_datetime|`[to_utc: true]`|
381 | |`October 1995`|`1995-10-01`|parse_date|`[assume_date: ~D[0001-12-01]]`|
382 | |`Saturday 23rd June 2020`|`2020-06-23`|parse_date| |
383 | |`Sep-19-16`|`2016-09-19`|parse_date| |
384 | |`Sep-19-16`|`2016-09-19T00:00:00`|parse_datetime|`[assume_time: true]`|
385 | |`Sun 01 January 2017 10:11:02 PM`|`2017-01-01`|parse_date| |
386 | |`Sun 01 January 2017 10:11:02 PM`|`2017-01-01T22:11:02`|parse_datetime| |
387 | |`Sun 31st Dec 2019`|`2019-12-31`|parse_date| |
388 | |`Sun Jan 08 2017 04:28:42 GMT+0000 (UTC)`|`2017-01-08T04:28:42Z`|parse| |
389 | |`Sun Jul  1 00:31:18 2018`|`2018-07-01T00:31:18`|parse| |
390 | |`Sun, 01 January 2017 10:11:02 PM`|`2017-01-01`|parse_date| |
391 | |`Sun, 01 January 2017 10:11:02 PM`|`2017-01-01T22:11:02`|parse_datetime| |
392 | |`Sunday 01 January 2017 09:22:46 AM`|`2017-01-01T09:22:46`|parse| |
393 | |`Sunday 01 January 2017 10:11:02 PM`|`2017-01-01`|parse_date| |
394 | |`Sunday 01 January 2017 10:11:02 PM`|`2017-01-01T22:11:02`|parse_datetime| |
395 | |`Sunday 01 January 2017 10:11:02 PM`|`2017-01-01T22:11:02`|parse| |
396 | |`Sunday 5th Jan 2025`|`2025-01-05`|parse_date| |
397 | |`Sunday 5th Jan 2025 10:30:00 AM`|`2025-01-05T10:30:00`|parse_datetime| |
398 | |`Sunday, 01 January 2017 10:11:02 PM`|`2017-01-01`|parse_date| |
399 | |`Sunday, 01 January 2017 10:11:02 PM`|`2017-01-01T22:11:02`|parse_datetime| |
400 | |`Thu Aug 09 2018 17:13:43 GMT+0000 (UTC)`|`2018-08-09T17:13:43Z`|parse| |
401 | |`Thu Feb 08 00:24:33 2018`|`2018-02-08T00:24:33`|parse| |
402 | |`Thu Jul  5 12:19:56 2018`|`2018-07-05T12:19:56`|parse| |
403 | |`Thursday 21st April 2022`|`2022-04-21`|parse_date| |
404 | |`Thursday 30 August 2018 11:31:18 AM`|`2018-08-30T11:31:18`|parse| |
405 | |`Tue Jul 31 06:44:39 2018`|`2018-07-31T06:44:39`|parse| |
406 | |`Tuesday 11 July 2017 1:43:46 PM`|`2017-07-11T13:43:46`|parse| |
407 | |`Tuesday 2nd February 2024`|`2024-02-02`|parse_date| |
408 | |`Tuesday 2nd February 2024 14:20:00`|`2024-02-02T14:20:00`|parse_datetime| |
409 | |`Wednesday 3rd March 2023`|`2023-03-03`|parse_date| |
410 | |`Wednesday 3rd March 2023 3:45 PM`|`2023-03-03T15:45:00`|parse_datetime| |
411 | |`jul-10-18`|`2018-07-10`|parse| |
412 | 


--------------------------------------------------------------------------------