dependabot-hex 0.119.0.beta1 → 0.119.4

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

@@ -1,11 +0,0 @@
-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/install-dir/hex/deps/jason/lib/helpers.ex

@@ -1,98 +0,0 @@
-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
-    kv_values = Macro.expand(kv, __CALLER__)
-    kv_vars = Enum.map(kv_values, fn {key, _} -> {key, generated_var(key, Codegen)} end)
-
-    values = Enum.map(kv_values, &elem(&1, 1))
-    vars = Enum.map(kv_vars, &elem(&1, 1))
-
-    escape = quote(do: escape)
-    encode_map = quote(do: encode_map)
-    encode_args = [escape, encode_map]
-    kv_iodata = Codegen.build_kv_iodata(kv_vars, encode_args)
-
-    quote do
-      {unquote_splicing(vars)} = {unquote_splicing(values)}
-
-      %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/install-dir/hex/deps/jason/lib/jason.ex

@@ -1,228 +0,0 @@
-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, boolean | 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 JavaScript.
-      * `:html_safe` - similar to `:javascript_safe`, but also escapes the `/`
-        character 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/install-dir/hex/deps/jason/mix.exs

@@ -1,76 +0,0 @@
-defmodule Jason.Mixfile do
-  use Mix.Project
-
-  @version "1.2.1"
-
-  def project() do
-    [
-      app: :jason,
-      version: @version,
-      elixir: "~> 1.4",
-      start_permanent: Mix.env() == :prod,
-      consolidate_protocols: Mix.env() != :test,
-      deps: deps(),
-      preferred_cli_env: [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},
-      {:dialyxir, "~> 1.0", 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 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

data/helpers/install-dir/hex/lib/check_update.exs

@@ -1,92 +0,0 @@
-defmodule UpdateChecker do
-  def run(dependency_name, credentials) do
-    set_credentials(credentials)
-
-    # Update the lockfile in a session that we can time out
-    task = Task.async(fn -> do_resolution(dependency_name) end)
-    case Task.yield(task, 30000) || Task.shutdown(task) do
-      {:ok, {:ok, :resolution_successful}} ->
-        # Read the new lock
-        {updated_lock, _updated_rest_lock} =
-          Map.split(Mix.Dep.Lock.read(), [String.to_atom(dependency_name)])
-
-        # Get the new dependency version
-        version =
-          updated_lock
-          |> Map.get(String.to_atom(dependency_name))
-          |> elem(2)
-        {:ok, version}
-
-      {:ok, {:error, error}} -> {:error, error}
-
-      nil -> {:error, :dependency_resolution_timed_out}
-
-      {:exit, reason} -> {:error, reason}
-    end
-  end
-
-  defp set_credentials(credentials) do
-    credentials
-    |> Enum.reduce([], fn cred, acc ->
-      if List.last(acc) == nil || List.last(acc)[:token] do
-        List.insert_at(acc, -1, %{organization: cred})
-      else
-        {item, acc} = List.pop_at(acc, -1)
-        item = Map.put(item, :token, cred)
-        List.insert_at(acc, -1, item)
-      end
-    end)
-    |> Enum.each(fn cred ->
-      hexpm = Hex.Repo.get_repo("hexpm")
-
-      repo = %{
-        url: hexpm.url <> "/repos/#{cred.organization}",
-        public_key: nil,
-        auth_key: cred.token
-      }
-
-      Hex.Config.read()
-      |> Hex.Config.read_repos()
-      |> Map.put("hexpm:#{cred.organization}", repo)
-      |> Hex.Config.update_repos()
-    end)
-  end
-
-  defp do_resolution(dependency_name) do
-    # Fetch dependencies that needs updating
-    {dependency_lock, rest_lock} =
-      Map.split(Mix.Dep.Lock.read(), [String.to_atom(dependency_name)])
-
-    try do
-      Mix.Dep.Fetcher.by_name([dependency_name], dependency_lock, rest_lock, [])
-      {:ok, :resolution_successful}
-    rescue
-      error -> {:error, error}
-    end
-  end
-end
-
-[dependency_name | credentials] = System.argv()
-
-
-case UpdateChecker.run(dependency_name, credentials) do
-  {:ok, version} ->
-    version = :erlang.term_to_binary({:ok, version})
-    IO.write(:stdio, version)
-
-  {:error, %Hex.Version.InvalidRequirementError{} = error}  ->
-    result = :erlang.term_to_binary({:error, "Invalid requirement: #{error.requirement}"})
-    IO.write(:stdio, result)
-
-  {:error, %Mix.Error{} = error} ->
-    result = :erlang.term_to_binary({:error, "Dependency resolution failed: #{error.message}"})
-    IO.write(:stdio, result)
-
-  {:error, :dependency_resolution_timed_out} ->
-    # We do nothing here because Hex is already printing out a message in stdout
-    nil
-
-  {:error, error} ->
-    result = :erlang.term_to_binary({:error, "Unknown error in check_update: #{inspect(error)}"})
-    IO.write(:stdio, result)
-end