zf

zenflows testing
git clone https://s.sonu.ch/~srfsh/zf.git
Log | Files | Refs | Submodules | README | LICENSE

utils.ex (2870B)

      1 defmodule Absinthe.Utils do
      2   @doc """
      3   Camelize a word, respecting underscore prefixes.
      4 
      5   ## Examples
      6 
      7   With an uppercase first letter:
      8 
      9   ```
     10   iex> camelize("foo_bar")
     11   "FooBar"
     12   iex> camelize("foo")
     13   "Foo"
     14   iex> camelize("__foo_bar")
     15   "__FooBar"
     16   iex> camelize("__foo")
     17   "__Foo"
     18   iex> camelize("_foo")
     19   "_Foo"
     20   ```
     21 
     22   With a lowercase first letter:
     23   ```
     24   iex> camelize("foo_bar", lower: true)
     25   "fooBar"
     26   iex> camelize("foo", lower: true)
     27   "foo"
     28   iex> camelize("__foo_bar", lower: true)
     29   "__fooBar"
     30   iex> camelize("__foo", lower: true)
     31   "__foo"
     32   iex> camelize("_foo", lower: true)
     33   "_foo"
     34 
     35   ```
     36   """
     37   @spec camelize(binary, Keyword.t()) :: binary
     38   def camelize(word, opts \\ [])
     39 
     40   def camelize("_" <> word, opts) do
     41     "_" <> camelize(word, opts)
     42   end
     43 
     44   def camelize(word, opts) do
     45     case opts |> Enum.into(%{}) do
     46       %{lower: true} ->
     47         {first, rest} = String.split_at(Macro.camelize(word), 1)
     48         String.downcase(first) <> rest
     49 
     50       _ ->
     51         Macro.camelize(word)
     52     end
     53   end
     54 
     55   @doc false
     56   @spec escapable?(any()) :: boolean()
     57   def escapable?(value) do
     58     # if this doesn't blow up, the value can be escaped
     59     _ = Macro.escape(value)
     60     true
     61   rescue
     62     _ ->
     63       false
     64   end
     65 
     66   @doc false
     67   def placement_docs(placements, name) do
     68     placement = Enum.find(placements, &match?({^name, _}, &1))
     69     placement_docs([placement])
     70   end
     71 
     72   def placement_docs([{_, placement} | _]) do
     73     placement
     74     |> do_placement_docs
     75   end
     76 
     77   defp do_placement_docs(toplevel: true) do
     78     """
     79     Top level in module.
     80     """
     81   end
     82 
     83   defp do_placement_docs(toplevel: false) do
     84     """
     85     Allowed under any block. Not allowed to be top level
     86     """
     87   end
     88 
     89   defp do_placement_docs(under: under) when is_list(under) do
     90     under =
     91       under
     92       |> Enum.sort_by(& &1)
     93       |> Enum.map(&"`#{&1}`")
     94       |> Enum.join(" ")
     95 
     96     """
     97     Allowed under: #{under}
     98     """
     99   end
    100 
    101   defp do_placement_docs(under: under) do
    102     do_placement_docs(under: [under])
    103   end
    104 
    105   @doc false
    106   def describe_builtin_module(module) do
    107     title =
    108       module
    109       |> Module.split()
    110       |> List.last()
    111 
    112     types =
    113       module.__absinthe_types__
    114       |> Map.keys()
    115       |> Enum.sort_by(& &1)
    116       |> Enum.map(fn identifier ->
    117         type = module.__absinthe_type__(identifier)
    118 
    119         """
    120         ## #{type.name}
    121         Identifier: `#{inspect(identifier)}`
    122 
    123         #{type.description}
    124         """
    125       end)
    126 
    127     directives =
    128       module.__absinthe_directives__
    129       |> Map.keys()
    130       |> Enum.sort_by(& &1)
    131       |> Enum.map(fn identifier ->
    132         directive = module.__absinthe_directive__(identifier)
    133 
    134         """
    135         ## #{directive.name}
    136         Identifier: `#{inspect(identifier)}`
    137 
    138         #{directive.description}
    139         """
    140       end)
    141 
    142     """
    143     # #{title}
    144 
    145     #{types ++ directives}
    146     """
    147   end
    148 end