dependabot-hex 0.119.0.beta1 → 0.119.4

data/helpers/install-dir/hex/deps/jason/lib/encoder.ex

@@ -1,216 +0,0 @@
-defprotocol Jason.Encoder do
-  @moduledoc """
-  Protocol controlling how a value is encoded to JSON.
-
-  ## Deriving
-
-  The protocol allows leveraging the Elixir's `@derive` feature
-  to simplify protocol implementation in trivial cases. Accepted
-  options are:
-
-    * `:only` - encodes only values of specified keys.
-    * `:except` - encodes all struct fields except specified keys.
-
-  By default all keys except the `:__struct__` key are encoded.
-
-  ## Example
-
-  Let's assume a presence of the following struct:
-
-      defmodule Test do
-        defstruct [:foo, :bar, :baz]
-      end
-
-  If we were to call `@derive Jason.Encoder` just before `defstruct`,
-  an implementation similar to the following implementation would be generated:
-
-      defimpl Jason.Encoder, for: Test do
-        def encode(value, opts) do
-          Jason.Encode.map(Map.take(value, [:foo, :bar, :baz]), opts)
-        end
-      end
-
-  If we called `@derive {Jason.Encoder, only: [:foo]}`, an implementation
-  similar to the following implementation would be generated:
-
-      defimpl Jason.Encoder, for: Test do
-        def encode(value, opts) do
-          Jason.Encode.map(Map.take(value, [:foo]), opts)
-        end
-      end
-
-  If we called `@derive {Jason.Encoder, except: [:foo]}`, an implementation
-  similar to the following implementation would be generated:
-
-      defimpl Jason.Encoder, for: Test do
-        def encode(value, opts) do
-          Jason.Encode.map(Map.take(value, [:bar, :baz]), opts)
-        end
-      end
-
-  The actually generated implementations are more efficient computing some data
-  during compilation similar to the macros from the `Jason.Helpers` module.
-
-  ## Explicit implementation
-
-  If you wish to implement the protocol fully yourself, it is advised to
-  use functions from the `Jason.Encode` module to do the actual iodata
-  generation - they are highly optimized and verified to always produce
-  valid JSON.
-  """
-
-  @type t :: term
-  @type opts :: Jason.Encode.opts()
-
-  @fallback_to_any true
-
-  @doc """
-  Encodes `value` to JSON.
-
-  The argument `opts` is opaque - it can be passed to various functions in
-  `Jason.Encode` (or to the protocol function itself) for encoding values to JSON.
-  """
-  @spec encode(t, opts) :: iodata
-  def encode(value, opts)
-end
-
-defimpl Jason.Encoder, for: Any do
-  defmacro __deriving__(module, struct, opts) do
-    fields = fields_to_encode(struct, opts)
-    kv = Enum.map(fields, &{&1, generated_var(&1, __MODULE__)})
-    escape = quote(do: escape)
-    encode_map = quote(do: encode_map)
-    encode_args = [escape, encode_map]
-    kv_iodata = Jason.Codegen.build_kv_iodata(kv, encode_args)
-
-    quote do
-      defimpl Jason.Encoder, for: unquote(module) do
-        require Jason.Helpers
-
-        def encode(%{unquote_splicing(kv)}, {unquote(escape), unquote(encode_map)}) do
-          unquote(kv_iodata)
-        end
-      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
-
-  def encode(%_{} = struct, _opts) do
-    raise Protocol.UndefinedError,
-      protocol: @protocol,
-      value: struct,
-      description: """
-      Jason.Encoder protocol must always be explicitly implemented.
-
-      If you own the struct, you can derive the implementation specifying \
-      which fields should be encoded to JSON:
-
-          @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:
-
-          @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:
-
-          Protocol.derive(Jason.Encoder, NameOfTheStruct, only: [...])
-          Protocol.derive(Jason.Encoder, NameOfTheStruct)
-      """
-  end
-
-  def encode(value, _opts) do
-    raise Protocol.UndefinedError,
-      protocol: @protocol,
-      value: value,
-      description: "Jason.Encoder protocol must always be explicitly implemented"
-  end
-
-  defp fields_to_encode(struct, opts) do
-    cond do
-      only = Keyword.get(opts, :only) ->
-        only
-
-      except = Keyword.get(opts, :except) ->
-        Map.keys(struct) -- [:__struct__ | except]
-
-      true ->
-        Map.keys(struct) -- [:__struct__]
-    end
-  end
-end
-
-# The following implementations are formality - they are already covered
-# by the main encoding mechanism in Jason.Encode, but exist mostly for
-# documentation purposes and if anybody had the idea to call the protocol directly.
-
-defimpl Jason.Encoder, for: Atom do
-  def encode(atom, opts) do
-    Jason.Encode.atom(atom, opts)
-  end
-end
-
-defimpl Jason.Encoder, for: Integer do
-  def encode(integer, _opts) do
-    Jason.Encode.integer(integer)
-  end
-end
-
-defimpl Jason.Encoder, for: Float do
-  def encode(float, _opts) do
-    Jason.Encode.float(float)
-  end
-end
-
-defimpl Jason.Encoder, for: List do
-  def encode(list, opts) do
-    Jason.Encode.list(list, opts)
-  end
-end
-
-defimpl Jason.Encoder, for: Map do
-  def encode(map, opts) do
-    Jason.Encode.map(map, opts)
-  end
-end
-
-defimpl Jason.Encoder, for: BitString do
-  def encode(binary, opts) when is_binary(binary) do
-    Jason.Encode.string(binary, opts)
-  end
-
-  def encode(bitstring, _opts) do
-    raise Protocol.UndefinedError,
-      protocol: @protocol,
-      value: bitstring,
-      description: "cannot encode a bitstring to JSON"
-  end
-end
-
-defimpl Jason.Encoder, for: [Date, Time, NaiveDateTime, DateTime] do
-  def encode(value, _opts) do
-    [?\", @for.to_iso8601(value), ?\"]
-  end
-end
-
-defimpl Jason.Encoder, for: Decimal do
-  def encode(value, _opts) do
-    # silence the xref warning
-    decimal = Decimal
-    [?\", decimal.to_string(value), ?\"]
-  end
-end
-
-defimpl Jason.Encoder, for: Jason.Fragment do
-  def encode(%{encode: encode}, opts) do
-    encode.(opts)
-  end
-end

data/helpers/install-dir/hex/deps/jason/lib/formatter.ex

@@ -1,253 +0,0 @@
-defmodule Jason.Formatter do
-  @moduledoc ~S"""
-  Pretty-printing and minimizing functions for JSON-encoded data.
-
-  Input is required to be in an 8-bit-wide encoding such as UTF-8 or Latin-1
-  in `t:iodata/0` format. Input must ve valid JSON, invalid JSON may produce
-  unexpected results or errors.
-  """
-
-  @type opts :: [
-          {:indent, iodata}
-          | {:line_separator, iodata}
-          | {:record_separator, iodata}
-          | {:after_colon, iodata}
-        ]
-
-  import Record
-  defrecordp :opts, [:indent, :line, :record, :colon]
-
-  @doc ~S"""
-  Pretty-prints JSON-encoded `input`.
-
-  `input` may contain multiple JSON objects or arrays, optionally separated
-  by whitespace (e.g., one object per line). Objects in output will be
-  separated by newlines. No trailing newline is emitted.
-
-  ## Options
-
-    * `:indent` - used for nested objects and arrays (default: two spaces - `"  "`);
-    * `:line_separator` - used in nested objects (default: `"\n"`);
-    * `:record_separator` - separates root-level objects and arrays
-      (default is the value for `:line_separator` option);
-    * `:after_colon` - printed after a colon inside objects (default: one space - `" "`).
-
-  ## Examples
-
-      iex> Jason.Formatter.pretty_print(~s|{"a":{"b": [1, 2]}}|)
-      ~s|{
-        "a": {
-          "b": [
-            1,
-            2
-          ]
-        }
-      }|
-
-  """
-  @spec pretty_print(iodata, opts) :: binary
-  def pretty_print(input, opts \\ []) do
-    input
-    |> pretty_print_to_iodata(opts)
-    |> IO.iodata_to_binary()
-  end
-
-  @doc ~S"""
-  Pretty-prints JSON-encoded `input` and returns iodata.
-
-  This function should be preferred to `pretty_print/2`, if the pretty-printed
-  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.
-  """
-  @spec pretty_print_to_iodata(iodata, opts) :: iodata
-  def pretty_print_to_iodata(input, opts \\ []) do
-    opts = parse_opts(opts, "  ", "\n", nil, " ")
-
-    depth = :first
-    empty = false
-
-    {output, _state} = pp_iodata(input, [], depth, empty, opts)
-
-    output
-  end
-
-  @doc ~S"""
-  Minimizes JSON-encoded `input`.
-
-  `input` may contain multiple JSON objects or arrays, optionally
-  separated by whitespace (e.g., one object per line). Minimized
-  output will contain one object per line. No trailing newline is emitted.
-
-  ## Options
-
-    * `:record_separator` - controls the string used as newline (default: `"\n"`).
-
-  ## Examples
-
-      iex> Jason.Formatter.minimize(~s|{ "a" : "b" , "c": \n\n 2}|)
-      ~s|{"a":"b","c":2}|
-
-  """
-  @spec minimize(iodata, opts) :: binary
-  def minimize(input, opts \\ []) do
-    input
-    |> minimize_to_iodata(opts)
-    |> IO.iodata_to_binary()
-  end
-
-  @doc ~S"""
-  Minimizes JSON-encoded `input` and returns iodata.
-
-  This function should be preferred to `minimize/2`, if the minimized
-  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.
-  """
-  @spec minimize_to_iodata(iodata, opts) :: iodata
-  def minimize_to_iodata(input, opts) do
-    record = Keyword.get(opts, :record_separator, "\n")
-    opts = opts(indent: "", line: "", record: record, colon: "")
-
-    depth = :first
-    empty = false
-
-    {output, _state} = pp_iodata(input, [], depth, empty, opts)
-
-    output
-  end
-
-  defp parse_opts([{option, value} | opts], indent, line, record, colon) do
-    value = IO.iodata_to_binary(value)
-    case option do
-      :indent -> parse_opts(opts, value, line, record, colon)
-      :record_separator -> parse_opts(opts, indent, line, value, colon)
-      :after_colon -> parse_opts(opts, indent, line, record, value)
-      :line_separator -> parse_opts(opts, indent, value, record || value, colon)
-    end
-  end
-
-  defp parse_opts([], indent, line, record, colon) do
-    opts(indent: indent, line: line, record: record || line, colon: colon)
-  end
-
-  for depth <- 1..16 do
-    defp tab("  ", unquote(depth)), do: unquote(String.duplicate("  ", depth))
-  end
-
-  defp tab("", _), do: ""
-  defp tab(indent, depth), do: List.duplicate(indent, depth)
-
-  defp pp_iodata(<<>>, output_acc, depth, empty, opts) do
-    {output_acc, &pp_iodata(&1, &2, depth, empty, opts)}
-  end
-
-  defp pp_iodata(<<byte, rest::binary>>, output_acc, depth, empty, opts) do
-    pp_byte(byte, rest, output_acc, depth, empty, opts)
-  end
-
-  defp pp_iodata([], output_acc, depth, empty, opts) do
-    {output_acc, &pp_iodata(&1, &2, depth, empty, opts)}
-  end
-
-  defp pp_iodata([byte | rest], output_acc, depth, empty, opts) when is_integer(byte) do
-    pp_byte(byte, rest, output_acc, depth, empty, opts)
-  end
-
-  defp pp_iodata([head | tail], output_acc, depth, empty, opts) do
-    {output_acc, cont} = pp_iodata(head, output_acc, depth, empty, opts)
-    cont.(tail, output_acc)
-  end
-
-  defp pp_byte(byte, rest, output, depth, empty, opts) when byte in ' \n\r\t' do
-    pp_iodata(rest, output, depth, empty, opts)
-  end
-
-  defp pp_byte(byte, rest, output, depth, empty, opts) when byte in '{[' do
-    {out, depth} =
-      cond do
-        depth == :first -> {byte, 1}
-        depth == 0 -> {[opts(opts, :record), byte], 1}
-        empty -> {[opts(opts, :line), tab(opts(opts, :indent), depth), byte], depth + 1}
-        true -> {byte, depth + 1}
-      end
-
-    empty = true
-    pp_iodata(rest, [output, out], depth, empty, opts)
-  end
-
-  defp pp_byte(byte, rest, output, depth, true = _empty, opts) when byte in '}]' do
-    empty = false
-    depth = depth - 1
-    pp_iodata(rest, [output, byte], depth, empty, opts)
-  end
-
-  defp pp_byte(byte, rest, output, depth, false = empty, opts) when byte in '}]' do
-    depth = depth - 1
-    out = [opts(opts, :line), tab(opts(opts, :indent), depth), byte]
-    pp_iodata(rest, [output, out], depth, empty, opts)
-  end
-
-  defp pp_byte(byte, rest, output, depth, _empty, opts) when byte in ',' do
-    empty = false
-    out = [byte, opts(opts, :line), tab(opts(opts, :indent), depth)]
-    pp_iodata(rest, [output, out], depth, empty, opts)
-  end
-
-  defp pp_byte(byte, rest, output, depth, empty, opts) when byte in ':' do
-    out = [byte, opts(opts, :colon)]
-    pp_iodata(rest, [output, out], depth, empty, opts)
-  end
-
-  defp pp_byte(byte, rest, output, depth, empty, opts) do
-    out = if empty, do: [opts(opts, :line), tab(opts(opts, :indent), depth), byte], else: byte
-    empty = false
-
-    if byte == ?" do
-      pp_string(rest, [output, out], _in_bs = false, &pp_iodata(&1, &2, depth, empty, opts))
-    else
-      pp_iodata(rest, [output, out], depth, empty, opts)
-    end
-  end
-
-  defp pp_string(<<>>, output_acc, in_bs, cont) do
-    {output_acc, &pp_string(&1, &2, in_bs, cont)}
-  end
-
-  defp pp_string(binary, output_acc, true = _in_bs, cont) when is_binary(binary) do
-    <<byte, rest::binary>> = binary
-    pp_string(rest, [output_acc, byte], false, cont)
-  end
-
-  defp pp_string(binary, output_acc, false = _in_bs, cont) when is_binary(binary) do
-    case :binary.match(binary, ["\"", "\\"]) do
-      :nomatch ->
-        {[output_acc | binary], &pp_string(&1, &2, false, cont)}
-      {pos, 1} ->
-        {head, tail} = :erlang.split_binary(binary, pos + 1)
-        case :binary.at(binary, pos) do
-          ?\\ -> pp_string(tail, [output_acc | head], true, cont)
-          ?" -> cont.(tail, [output_acc | head])
-        end
-    end
-  end
-
-  defp pp_string([], output_acc, in_bs, cont) do
-    {output_acc, &pp_string(&1, &2, in_bs, cont)}
-  end
-
-  defp pp_string([byte | rest], output_acc, in_bs, cont) when is_integer(byte) do
-    cond do
-      in_bs -> pp_string(rest, [output_acc, byte], false, cont)
-      byte == ?" -> cont.(rest, [output_acc, byte])
-      true -> pp_string(rest, [output_acc, byte], byte == ?\\, cont)
-    end
-  end
-
-  defp pp_string([head | tail], output_acc, in_bs, cont) do
-    {output_acc, cont} = pp_string(head, output_acc, in_bs, cont)
-    cont.(tail, output_acc)
-  end
-end