dependabot-hex 0.107.13 → 0.107.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15aedfe164174c16c904b23b71e30a3b273dff70b8713ed84aca18f93a1231d7
-  data.tar.gz: fd41f3bb22069f06ee8154d8644a0557433edbccb281a3121467d6d2d979c568
+  metadata.gz: bdfcd650744ba2ee91ce3df24d3f52491cd67114662992284e4a5a25b225138a
+  data.tar.gz: d0fb29f7affd691ca9b4548352b4c760e5656edb42501c6a6d4c0ab126d01705
 SHA512:
-  metadata.gz: b8fe78438ccdb4c6e46a854f77d19286895603a2d991bf09627007fbf648734ef3587d1c87ad320901f5e47b0fabba7c2f75c332550d2ffc458c26b54c16a901
-  data.tar.gz: 0e535724ef7f5fde110c00b0b8498ff418c13645688a8e46e47f371dbd07ad7cc754a4203e4a37241e48f1614f51c65f3fb58b40913eda914bd2721496ed8515
+  metadata.gz: 30e28d4e7f5a7567f4e6b5832249ee46980d55d63194e1f222fd58fd7e207b5566874e3f718857c428e2c0e3c74f2bcd266fe1938312f8f5c3d299ff817c64a0
+  data.tar.gz: c9750bfdac7b2268a43f1f242da587f3b50240bac1cb54fd230138bd36acc5b6d785bf5b4e2dc22ce61639b8401ab34a5c62dc68c70e987d6cf8a7654e874778

data/helpers/deps/jason/.hex

@@ -0,0 +1,2 @@
+jason,1.1.2,b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7,hexpm
+mix

data/helpers/deps/jason/CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+
+## 1.1.2 (19.10.2018)
+
+### Bug fixes
+
+* correctly handle the `pretty: false` option
+  ([ba318c8](https://github.com/michalmuskala/jason/commit/ba318c8)).
+
+## 1.1.1 (10.07.2018)
+
+### Bug fixes
+
+* correctly handle escape sequences in strings when pretty printing
+  ([794bbe4](https://github.com/michalmuskala/jason/commit/794bbe4)).
+
+## 1.1.0 (02.07.2018)
+
+### Enhancements
+
+* pretty-printing support through `Jason.Formatter` and `pretty: true` option
+  in `Jason.encode/2` ([d758e36](https://github.com/michalmuskala/jason/commit/d758e36)).
+
+### Bug fixes
+
+* silence variable warnings for fields with underscores used during deriving
+  ([88dd85c](https://github.com/michalmuskala/jason/commit/88dd85c)).
+* **potential incompatibility** don't raise `Protocol.UndefinedError` in non-bang functions
+  ([ad0f57b](https://github.com/michalmuskala/jason/commit/ad0f57b)).
+
+## 1.0.1 (02.07.2018)
+
+### Bug fixes
+
+* fix `Jason.Encode.escape` type ([a57b430](https://github.com/michalmuskala/jason/commit/a57b430))
+* multiple documentation improvements
+
+## 1.0.0 (26.01.2018)
+
+No changes
+
+## 1.0.0-rc.3 (26.01.2018)
+
+### Changes
+
+* update `escape` option of `Jason.encode/2` to take values:
+  `:json | :unicode_safe | :html_safe | :javascript_safe` for consistency. Old values of
+  `:unicode` and `:javascript` are still supported for compatibility with Poison.
+  ([f42dcbd](https://github.com/michalmuskala/jason/commit/f42dcbd))
+
+## 1.0.0-rc.2 (07.01.2018)
+
+### Bug fixes
+
+* add type for `strings` option ([b459ee4](https://github.com/michalmuskala/jason/commit/b459ee4))
+* support iodata in `decode!` ([a1f3456](https://github.com/michalmuskala/jason/commit/a1f3456))
+
+## 1.0.0-rc.1 (22.12.2017)
+
+Initial release

data/helpers/deps/jason/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2017 Michał Muskała
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/helpers/deps/jason/README.md

@@ -0,0 +1,179 @@
+# Jason
+
+A blazing fast JSON parser and generator in pure Elixir.
+
+The parser and generator are at least twice as fast as other Elixir/Erlang libraries
+(most notably `Poison`).
+The performance is comparable to `jiffy`, which is implemented in C as a NIF.
+Jason is usually only twice as slow.
+
+Both parser and generator fully conform to
+[RFC 8259](https://tools.ietf.org/html/rfc8259) and
+[ECMA 404](http://www.ecma-international.org/publications/standards/Ecma-404.htm)
+standards. The parser is tested using [JSONTestSuite](https://github.com/nst/JSONTestSuite).
+
+## Installation
+
+The package can be installed by adding `jason` to your list of dependencies
+in `mix.exs`:
+
+```elixir
+def deps do
+  [{:jason, "~> 1.1"}]
+end
+```
+
+## Basic Usage
+
+``` elixir
+iex(1)> Jason.encode!(%{"age" => 44, "name" => "Steve Irwin", "nationality" => "Australian"})
+"{\"age\":44,\"name\":\"Steve Irwin\",\"nationality\":\"Australian\"}"
+
+iex(2)> Jason.decode!(~s({"age":44,"name":"Steve Irwin","nationality":"Australian"}))
+%{"age" => 44, "name" => "Steve Irwin", "nationality" => "Australian"}
+```
+
+Full documentation can be found at [https://hexdocs.pm/jason](https://hexdocs.pm/jason).
+
+## Use with other libraries
+
+### Postgrex
+
+You need to define a custom "types" module in an `.ex` file, somewhere in `lib`:
+
+```elixir
+Postgrex.Types.define(MyApp.PostgresTypes, [], json: Jason)
+
+## If using with ecto, you also need to pass ecto default extensions:
+
+Postgrex.Types.define(MyApp.PostgresTypes, [] ++ Ecto.Adapters.Postgres.extensions(), json: Jason)
+```
+
+Then you can use the module, by passing it to `Postgrex.start_link`.
+### Ecto
+
+To replicate fully the current behaviour of `Poison` when used in Ecto applications,
+you need to configure `Jason` to be the default encoder in `config/config.exs`:
+
+```elixir
+config :ecto, json_library: Jason
+```
+
+Additionally, when using PostgreSQL, you need to define a custom types module as described
+above, and configure your repo to use it (in either `config/config.exs` or `config/<env>.exs`):
+
+```elixir
+config :my_app, MyApp.Repo, types: MyApp.PostgresTypes
+```
+
+### Plug (and Phoenix)
+
+First, you need to configure `Plug.Parsers` to use `Jason` for parsing JSON. You need to find,
+where you're plugging the `Plug.Parsers` plug (in case of Phoenix, it will be in the
+Endpoint module) and configure it in your endpoint module (`lib/app_web/endpoint.ex`),
+for example:
+
+```elixir
+plug Plug.Parsers,
+  parsers: [:urlencoded, :multipart, :json],
+  pass: ["*/*"],
+  json_decoder: Jason
+```
+
+Additionally, for Phoenix, you need to configure the "encoder" in `config/config.exs`:
+
+```elixir
+config :phoenix, :format_encoders,
+  json: Jason
+```
+
+A custom JSON encoder for Phoenix channels is unfortunately a bit more involved,
+you can find code for a custom serializer and how to use it [in here](https://gist.github.com/michalmuskala/d5fabcd26be2befdfb72b72e0b0f2797).
+
+### Absinthe
+
+You need to pass the `:json_codec` option to `Absinthe.Plug`
+
+```elixir
+# When called directly:
+plug Absinthe.Plug,
+  schema: MyApp.Schema,
+  json_codec: Jason
+
+# When used in phoenix router:
+forward "/api",
+  to: Absinthe.Plug,
+  init_opts: [schema: MyApp.Schema, json_codec: Jason]
+```
+
+## Benchmarks
+
+Detailed benchmarks (including memory measurements):
+https://gist.github.com/michalmuskala/4d64a5a7696ca84ac7c169a0206640d5
+
+HTML reports for the benchmark (only performance measurements):
+http://michal.muskala.eu/jason/decode.html and http://michal.muskala.eu/jason/encode.html
+
+### Running
+
+Benchmarks against most popular Elixir & Erlang json libraries can be executed
+with `mix bench.encode` and `mix bench.decode`.
+A HTML report of the benchmarks (after their execution) can be found in
+`bench/output/encode.html` and `bench/output/decode.html` respectively.
+
+## Differences to Poison
+
+Jason has a couple feature differences compared to Poison.
+
+  * Jason follows the JSON spec more strictly, for example it does not allow
+    unescaped newline characters in JSON strings - e.g. `"\"\n\""` will
+    produce a decoding error.
+  * no support for decoding into data structures (the `as:` option).
+  * no built-in encoders for `MapSet`, `Range` and `Stream`.
+  * no support for encoding arbitrary structs - explicit implementation
+    of the `Jason.Encoder` protocol is always required.
+  * different pretty-printing customisation options (default `pretty: true` works the same)
+
+If you require encoders for any of the unsupported collection types, I suggest
+adding the needed implementations directly to your project:
+
+```elixir
+defimpl Jason.Encoder, for: [MapSet, Range, Stream] do
+  def encode(struct, opts) do
+    Jason.Encode.list(Enum.to_list(struct), opts)
+  end
+end
+```
+
+If you need to encode some struct that does not implement the protocol,
+if you own the struct, you can derive the implementation specifying
+which fields should be encoded to JSON:
+
+```elixir
+@derive {Jason.Encoder, only: [....]}
+defstruct # ...
+```
+
+It is also possible to encode all fields, although this should be
+used carefully to avoid accidentally leaking private information
+when new fields are added:
+
+```elixir
+@derive Jason.Encoder
+defstruct # ...
+```
+
+Finally, if you don't own the struct you want to encode to JSON,
+you may use `Protocol.derive/3` placed outside of any module:
+
+```elixir
+Protocol.derive(Jason.Encoder, NameOfTheStruct, only: [...])
+Protocol.derive(Jason.Encoder, NameOfTheStruct)
+```
+
+## License
+
+Jason is released under the Apache 2.0 License - see the [LICENSE](LICENSE) file.
+
+Some elements of tests and benchmarks have their origins in the
+[Poison library](https://github.com/devinus/poison) and were initially licensed under [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).

data/helpers/deps/jason/hex_metadata.config

@@ -0,0 +1,20 @@
+{<<"app">>,<<"jason">>}.
+{<<"build_tools">>,[<<"mix">>]}.
+{<<"description">>,
+ <<"A blazing fast JSON parser and generator in pure Elixir.">>}.
+{<<"elixir">>,<<"~> 1.4">>}.
+{<<"files">>,
+ [<<"lib">>,<<"lib/codegen.ex">>,<<"lib/decoder.ex">>,<<"lib/encode.ex">>,
+  <<"lib/encoder.ex">>,<<"lib/formatter.ex">>,<<"lib/fragment.ex">>,
+  <<"lib/helpers.ex">>,<<"lib/jason.ex">>,<<"mix.exs">>,<<"README.md">>,
+  <<"LICENSE">>,<<"CHANGELOG.md">>]}.
+{<<"licenses">>,[<<"Apache 2.0">>]}.
+{<<"links">>,[{<<"GitHub">>,<<"https://github.com/michalmuskala/jason">>}]}.
+{<<"name">>,<<"jason">>}.
+{<<"requirements">>,
+ [[{<<"app">>,<<"decimal">>},
+   {<<"name">>,<<"decimal">>},
+   {<<"optional">>,true},
+   {<<"repository">>,<<"hexpm">>},
+   {<<"requirement">>,<<"~> 1.0">>}]]}.
+{<<"version">>,<<"1.1.2">>}.

data/helpers/deps/jason/lib/codegen.ex

@@ -0,0 +1,158 @@
+defmodule Jason.Codegen do
+  @moduledoc false
+
+  alias Jason.{Encode, EncodeError}
+
+  def jump_table(ranges, default) do
+    ranges
+    |> ranges_to_orddict()
+    |> :array.from_orddict(default)
+    |> :array.to_orddict()
+  end
+
+  def jump_table(ranges, default, max) do
+    ranges
+    |> ranges_to_orddict()
+    |> :array.from_orddict(default)
+    |> resize(max)
+    |> :array.to_orddict()
+  end
+
+  defmacro bytecase(var, do: clauses) do
+    {ranges, default, literals} = clauses_to_ranges(clauses, [])
+
+    jump_table = jump_table(ranges, default)
+
+    quote do
+      case unquote(var) do
+        unquote(jump_table_to_clauses(jump_table, literals))
+      end
+    end
+  end
+
+  defmacro bytecase(var, max, do: clauses) do
+    {ranges, default, empty} = clauses_to_ranges(clauses, [])
+
+    jump_table = jump_table(ranges, default, max)
+
+    quote do
+      case unquote(var) do
+        unquote(jump_table_to_clauses(jump_table, empty))
+      end
+    end
+  end
+
+  def build_kv_iodata(kv, encode_args) do
+    elements =
+      kv
+      |> Enum.map(&encode_pair(&1, encode_args))
+      |> Enum.intersperse(",")
+
+    collapse_static(List.flatten(["{", elements] ++ '}'))
+  end
+
+  defp clauses_to_ranges([{:->, _, [[{:in, _, [byte, range]}, rest], action]} | tail], acc) do
+    clauses_to_ranges(tail, [{range, {byte, rest, action}} | acc])
+  end
+
+  defp clauses_to_ranges([{:->, _, [[default, rest], action]} | tail], acc) do
+    {Enum.reverse(acc), {default, rest, action}, literal_clauses(tail)}
+  end
+
+  defp literal_clauses(clauses) do
+    Enum.map(clauses, fn {:->, _, [[literal], action]} ->
+      {literal, action}
+    end)
+  end
+
+  defp jump_table_to_clauses([{val, {{:_, _, _}, rest, action}} | tail], empty) do
+    quote do
+      <<unquote(val), unquote(rest)::bits>> ->
+        unquote(action)
+    end ++ jump_table_to_clauses(tail, empty)
+  end
+
+  defp jump_table_to_clauses([{val, {byte, rest, action}} | tail], empty) do
+    quote do
+      <<unquote(byte), unquote(rest)::bits>> when unquote(byte) === unquote(val) ->
+        unquote(action)
+    end ++ jump_table_to_clauses(tail, empty)
+  end
+
+  defp jump_table_to_clauses([], literals) do
+    Enum.flat_map(literals, fn {pattern, action} ->
+      quote do
+        unquote(pattern) ->
+          unquote(action)
+      end
+    end)
+  end
+
+  defmacro jump_table_case(var, rest, ranges, default) do
+    clauses =
+      ranges
+      |> jump_table(default)
+      |> Enum.flat_map(fn {byte_value, action} ->
+           quote do
+             <<unquote(byte_value), unquote(rest)::bits>> ->
+               unquote(action)
+           end
+         end)
+
+    clauses = clauses ++ quote(do: (<<>> -> empty_error(original, skip)))
+
+    quote do
+      case unquote(var) do
+        unquote(clauses)
+      end
+    end
+  end
+
+  defp resize(array, size), do: :array.resize(size, array)
+
+  defp ranges_to_orddict(ranges) do
+    ranges
+    |> Enum.flat_map(fn
+         {int, value} when is_integer(int) ->
+           [{int, value}]
+
+         {enum, value} ->
+           Enum.map(enum, &{&1, value})
+       end)
+    |> :orddict.from_list()
+  end
+
+  defp encode_pair({key, value}, encode_args) do
+    key = IO.iodata_to_binary(Encode.key(key, &escape_key/3))
+    key = "\"" <> key <> "\":"
+    [key, quote(do: Encode.value(unquote(value), unquote_splicing(encode_args)))]
+  end
+
+  defp escape_key(binary, _original, _skip) do
+    check_safe_key!(binary)
+    binary
+  end
+
+  defp check_safe_key!(binary) do
+    for <<(<<byte>> <- binary)>> do
+      if byte > 0x7F or byte < 0x1F or byte in '"\\/' do
+        raise EncodeError,
+              "invalid byte #{inspect(byte, base: :hex)} in literal key: #{inspect(binary)}"
+      end
+    end
+
+    :ok
+  end
+
+  defp collapse_static([bin1, bin2 | rest]) when is_binary(bin1) and is_binary(bin2) do
+    collapse_static([bin1 <> bin2 | rest])
+  end
+
+  defp collapse_static([other | rest]) do
+    [other | collapse_static(rest)]
+  end
+
+  defp collapse_static([]) do
+    []
+  end
+end