dependabot-hex 0.107.13 → 0.107.14

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

@@ -0,0 +1,11 @@
+defmodule Jason.Fragment do
+  defstruct [:encode]
+
+  def new(iodata) when is_list(iodata) or is_binary(iodata) do
+    %__MODULE__{encode: fn _ -> iodata end}
+  end
+
+  def new(encode) when is_function(encode, 1) do
+    %__MODULE__{encode: encode}
+  end
+end

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

@@ -0,0 +1,90 @@
+defmodule Jason.Helpers do
+  @moduledoc """
+  Provides macro facilities for partial compile-time encoding of JSON.
+  """
+
+  alias Jason.{Codegen, Fragment}
+
+  @doc ~S"""
+  Encodes a JSON map from a compile-time keyword.
+
+  Encodes the keys at compile time and strives to create as flat iodata
+  structure as possible to achieve maximum efficiency. Does encoding
+  right at the call site, but returns an `%Jason.Fragment{}` struct
+  that needs to be passed to one of the "main" encoding functions -
+  for example `Jason.encode/2` for final encoding into JSON - this
+  makes it completely transparent for most uses.
+
+  Only allows keys that do not require escaping in any of the supported
+  encoding modes. This means only ASCII characters from the range
+  0x1F..0x7F excluding '\', '/' and '"' are allowed - this also excludes
+  all control characters like newlines.
+
+  Preserves the order of the keys.
+
+  ## Example
+
+      iex> fragment = json_map(foo: 1, bar: 2)
+      iex> Jason.encode!(fragment)
+      "{\"foo\":1,\"bar\":2}"
+
+  """
+  defmacro json_map(kv) do
+    escape = quote(do: escape)
+    encode_map = quote(do: encode_map)
+    encode_args = [escape, encode_map]
+    kv_iodata = Codegen.build_kv_iodata(Macro.expand(kv, __CALLER__), encode_args)
+
+    quote do
+      %Fragment{
+        encode: fn {unquote(escape), unquote(encode_map)} ->
+          unquote(kv_iodata)
+        end
+      }
+    end
+  end
+
+  @doc ~S"""
+  Encodes a JSON map from a variable containing a map and a compile-time
+  list of keys.
+
+  It is equivalent to calling `Map.take/2` before encoding. Otherwise works
+  similar to `json_map/2`.
+
+  ## Example
+
+      iex> map = %{a: 1, b: 2, c: 3}
+      iex> fragment = json_map_take(map, [:c, :b])
+      iex> Jason.encode!(fragment)
+      "{\"c\":3,\"b\":2}"
+
+  """
+  defmacro json_map_take(map, take) do
+    take = Macro.expand(take, __CALLER__)
+    kv = Enum.map(take, &{&1, generated_var(&1, Codegen)})
+    escape = quote(do: escape)
+    encode_map = quote(do: encode_map)
+    encode_args = [escape, encode_map]
+    kv_iodata = Codegen.build_kv_iodata(kv, encode_args)
+
+    quote do
+      case unquote(map) do
+        %{unquote_splicing(kv)} ->
+          %Fragment{
+            encode: fn {unquote(escape), unquote(encode_map)} ->
+              unquote(kv_iodata)
+            end
+          }
+
+        other ->
+          raise ArgumentError,
+                "expected a map with keys: #{unquote(inspect(take))}, got: #{inspect(other)}"
+      end
+    end
+  end
+
+  # The same as Macro.var/2 except it sets generated: true
+  defp generated_var(name, context) do
+    {name, [generated: true], context}
+  end
+end

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

@@ -0,0 +1,228 @@
+defmodule Jason do
+  @moduledoc """
+  A blazing fast JSON parser and generator in pure Elixir.
+  """
+
+  alias Jason.{Encode, Decoder, DecodeError, EncodeError, Formatter}
+
+  @type escape :: :json | :unicode_safe | :html_safe | :javascript_safe
+  @type maps :: :naive | :strict
+
+  @type encode_opt :: {:escape, escape} | {:maps, maps} | {:pretty, true | Formatter.opts()}
+
+  @type keys :: :atoms | :atoms! | :strings | :copy | (String.t() -> term)
+
+  @type strings :: :reference | :copy
+
+  @type decode_opt :: {:keys, keys} | {:strings, strings}
+
+  @doc """
+  Parses a JSON value from `input` iodata.
+
+  ## Options
+
+    * `:keys` - controls how keys in objects are decoded. Possible values are:
+
+      * `:strings` (default) - decodes keys as binary strings,
+      * `:atoms` - keys are converted to atoms using `String.to_atom/1`,
+      * `:atoms!` - keys are converted to atoms using `String.to_existing_atom/1`,
+      * custom decoder - additionally a function accepting a string and returning a key
+        is accepted.
+
+    * `:strings` - controls how strings (including keys) are decoded. Possible values are:
+
+      * `:reference` (default) - when possible tries to create a sub-binary into the original
+      * `:copy` - always copies the strings. This option is especially useful when parts of the
+        decoded data will be stored for a long time (in ets or some process) to avoid keeping
+        the reference to the original data.
+
+  ## Decoding keys to atoms
+
+  The `:atoms` option uses the `String.to_atom/1` call that can create atoms at runtime.
+  Since the atoms are not garbage collected, this can pose a DoS attack vector when used
+  on user-controlled data.
+
+  ## Examples
+
+      iex> Jason.decode("{}")
+      {:ok, %{}}
+
+      iex> Jason.decode("invalid")
+      {:error, %Jason.DecodeError{data: "invalid", position: 0, token: nil}}
+  """
+  @spec decode(iodata, [decode_opt]) :: {:ok, term} | {:error, DecodeError.t()}
+  def decode(input, opts \\ []) do
+    input = IO.iodata_to_binary(input)
+    Decoder.parse(input, format_decode_opts(opts))
+  end
+
+  @doc """
+  Parses a JSON value from `input` iodata.
+
+  Similar to `decode/2` except it will unwrap the error tuple and raise
+  in case of errors.
+
+  ## Examples
+
+      iex> Jason.decode!("{}")
+      %{}
+
+      iex> Jason.decode!("invalid")
+      ** (Jason.DecodeError) unexpected byte at position 0: 0x69 ('i')
+
+  """
+  @spec decode!(iodata, [decode_opt]) :: term | no_return
+  def decode!(input, opts \\ []) do
+    case decode(input, opts) do
+      {:ok, result} -> result
+      {:error, error} -> raise error
+    end
+  end
+
+  @doc """
+  Generates JSON corresponding to `input`.
+
+  The generation is controlled by the `Jason.Encoder` protocol,
+  please refer to the module to read more on how to define the protocol
+  for custom data types.
+
+  ## Options
+
+    * `:escape` - controls how strings are encoded. Possible values are:
+
+      * `:json` (default) - the regular JSON escaping as defined by RFC 7159.
+      * `:javascript_safe` - additionally escapes the LINE SEPARATOR (U+2028)
+        and PARAGRAPH SEPARATOR (U+2029) characters to make the produced JSON
+        valid JavaSciprt.
+      * `:html_safe` - similar to `:javascript`, but also escapes the `/`
+        caracter to prevent XSS.
+      * `:unicode_safe` - escapes all non-ascii characters.
+
+    * `:maps` - controls how maps are encoded. Possible values are:
+
+      * `:strict` - checks the encoded map for duplicate keys and raises
+        if they appear. For example `%{:foo => 1, "foo" => 2}` would be
+        rejected, since both keys would be encoded to the string `"foo"`.
+      * `:naive` (default) - does not perform the check.
+
+    * `:pretty` - controls pretty printing of the output. Possible values are:
+
+      * `true` to pretty print with default configuration
+      * a keyword of options as specified by `Jason.Formatter.pretty_print/2`.
+
+  ## Examples
+
+      iex> Jason.encode(%{a: 1})
+      {:ok, ~S|{"a":1}|}
+
+      iex> Jason.encode("\\xFF")
+      {:error, %Jason.EncodeError{message: "invalid byte 0xFF in <<255>>"}}
+
+  """
+  @spec encode(term, [encode_opt]) ::
+          {:ok, String.t()} | {:error, EncodeError.t() | Exception.t()}
+  def encode(input, opts \\ []) do
+    case do_encode(input, format_encode_opts(opts)) do
+      {:ok, result} -> {:ok, IO.iodata_to_binary(result)}
+      {:error, error} -> {:error, error}
+    end
+  end
+
+  @doc """
+  Generates JSON corresponding to `input`.
+
+  Similar to `encode/1` except it will unwrap the error tuple and raise
+  in case of errors.
+
+  ## Examples
+
+      iex> Jason.encode!(%{a: 1})
+      ~S|{"a":1}|
+
+      iex> Jason.encode!("\\xFF")
+      ** (Jason.EncodeError) invalid byte 0xFF in <<255>>
+
+  """
+  @spec encode!(term, [encode_opt]) :: String.t() | no_return
+  def encode!(input, opts \\ []) do
+    case do_encode(input, format_encode_opts(opts)) do
+      {:ok, result} -> IO.iodata_to_binary(result)
+      {:error, error} -> raise error
+    end
+  end
+
+  @doc """
+  Generates JSON corresponding to `input` and returns iodata.
+
+  This function should be preferred to `encode/2`, if the generated
+  JSON will be handed over to one of the IO functions or sent
+  over the socket. The Erlang runtime is able to leverage vectorised
+  writes and avoid allocating a continuous buffer for the whole
+  resulting string, lowering memory use and increasing performance.
+
+  ## Examples
+
+      iex> {:ok, iodata} = Jason.encode_to_iodata(%{a: 1})
+      iex> IO.iodata_to_binary(iodata)
+      ~S|{"a":1}|
+
+      iex> Jason.encode_to_iodata("\\xFF")
+      {:error, %Jason.EncodeError{message: "invalid byte 0xFF in <<255>>"}}
+
+  """
+  @spec encode_to_iodata(term, [encode_opt]) ::
+          {:ok, iodata} | {:error, EncodeError.t() | Exception.t()}
+  def encode_to_iodata(input, opts \\ []) do
+    do_encode(input, format_encode_opts(opts))
+  end
+
+  @doc """
+  Generates JSON corresponding to `input` and returns iodata.
+
+  Similar to `encode_to_iodata/1` except it will unwrap the error tuple
+  and raise in case of errors.
+
+  ## Examples
+
+      iex> iodata = Jason.encode_to_iodata!(%{a: 1})
+      iex> IO.iodata_to_binary(iodata)
+      ~S|{"a":1}|
+
+      iex> Jason.encode_to_iodata!("\\xFF")
+      ** (Jason.EncodeError) invalid byte 0xFF in <<255>>
+
+  """
+  @spec encode_to_iodata!(term, [encode_opt]) :: iodata | no_return
+  def encode_to_iodata!(input, opts \\ []) do
+    case do_encode(input, format_encode_opts(opts)) do
+      {:ok, result} -> result
+      {:error, error} -> raise error
+    end
+  end
+
+  defp do_encode(input, %{pretty: true} = opts) do
+    case Encode.encode(input, opts) do
+      {:ok, encoded} -> {:ok, Formatter.pretty_print_to_iodata(encoded)}
+      other -> other
+    end
+  end
+
+  defp do_encode(input, %{pretty: pretty} = opts) when pretty !== false do
+    case Encode.encode(input, opts) do
+      {:ok, encoded} -> {:ok, Formatter.pretty_print_to_iodata(encoded, pretty)}
+      other -> other
+    end
+  end
+
+  defp do_encode(input, opts) do
+    Encode.encode(input, opts)
+  end
+
+  defp format_encode_opts(opts) do
+    Enum.into(opts, %{escape: :json, maps: :naive})
+  end
+
+  defp format_decode_opts(opts) do
+    Enum.into(opts, %{keys: :strings, strings: :reference})
+  end
+end

data/helpers/deps/jason/mix.exs

@@ -0,0 +1,92 @@
+defmodule Jason.Mixfile do
+  use Mix.Project
+
+  @version "1.1.2"
+
+  def project() do
+    [
+      app: :jason,
+      version: @version,
+      elixir: "~> 1.4",
+      start_permanent: Mix.env() == :prod,
+      consolidate_protocols: Mix.env() != :test,
+      deps: deps(),
+      aliases: aliases(),
+      preferred_cli_env: ["bench.encode": :bench, "bench.decode": :bench, docs: :docs],
+      dialyzer: dialyzer(),
+      description: description(),
+      package: package(),
+      docs: docs()
+    ]
+  end
+
+  def application() do
+    [
+      extra_applications: []
+    ]
+  end
+
+  defp deps() do
+    [
+      {:decimal, "~> 1.0", optional: true},
+      {:benchee, "~> 0.8", only: :bench},
+      {:benchee_html, "~> 0.1", only: :bench, github: "michalmuskala/benchee_html"},
+      {:poison, "~> 3.0", only: :bench},
+      {:exjsx, "~> 4.0", only: :bench},
+      {:tiny, "~> 1.0", only: :bench},
+      {:jsone, "~> 1.4", only: :bench},
+      {:jiffy, "~> 0.14", only: :bench},
+      {:json, "~> 1.0", only: :bench},
+      {:dialyxir, "~> 0.5", only: [:dev, :test], runtime: false},
+      {:ex_doc, "~> 0.18", only: :docs},
+    ] ++ maybe_stream_data()
+  end
+
+  defp maybe_stream_data() do
+    if Version.match?(System.version(), "~> 1.5") do
+      [{:stream_data, "~> 0.4", only: :test}]
+    else
+      []
+    end
+  end
+
+  defp aliases() do
+    [
+      "bench.encode": ["run bench/encode.exs"],
+      "bench.decode": ["run bench/decode.exs"]
+    ]
+  end
+
+  defp dialyzer() do
+    [
+      ignore_warnings: "dialyzer.ignore"
+    ]
+  end
+
+  defp description() do
+    """
+    A blazing fast JSON parser and generator in pure Elixir.
+    """
+  end
+
+  defp package() do
+    [
+      maintainers: ["Michał Muskała"],
+      licenses: ["Apache 2.0"],
+      links: %{"GitHub" => "https://github.com/michalmuskala/jason"}
+    ]
+  end
+
+  defp docs() do
+    [
+      main: "readme",
+      name: "Jason",
+      source_ref: "v#{@version}",
+      canonical: "http://hexdocs.pm/jason",
+      source_url: "https://github.com/michalmuskala/jason",
+      extras: [
+        "README.md"
+      ]
+    ]
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dependabot-hex
 version: !ruby/object:Gem::Version
-  version: 0.107.13
+  version: 0.107.14
 platform: ruby
 authors:
 - Dependabot
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.107.13
+        version: 0.107.14
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.107.13
+        version: 0.107.14
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -144,6 +144,21 @@ extensions: []
 extra_rdoc_files: []
 files:
 - helpers/build
+- helpers/deps/jason/.fetch
+- helpers/deps/jason/.hex
+- helpers/deps/jason/CHANGELOG.md
+- helpers/deps/jason/LICENSE
+- helpers/deps/jason/README.md
+- helpers/deps/jason/hex_metadata.config
+- helpers/deps/jason/lib/codegen.ex
+- helpers/deps/jason/lib/decoder.ex
+- helpers/deps/jason/lib/encode.ex
+- helpers/deps/jason/lib/encoder.ex
+- helpers/deps/jason/lib/formatter.ex
+- helpers/deps/jason/lib/fragment.ex
+- helpers/deps/jason/lib/helpers.ex
+- helpers/deps/jason/lib/jason.ex
+- helpers/deps/jason/mix.exs
 - helpers/lib/check_update.exs
 - helpers/lib/do_update.exs
 - helpers/lib/parse_deps.exs