defmodule ConvCase do
@moduledoc """
Functions to convert strings, atoms and map keys between `camelCase`,
`snake_case` and `kebab-case`.
Currently this functions do not support UTF-8.
If this package fits not your requirements then take a look here:
* [Macro.camelize/1](https://hexdocs.pm/elixir/Macro.html#camelize/1) and
[Macro.underscore/1](https://hexdocs.pm/elixir/Macro.html#underscore/1)
* [ReCase](https://github.com/sobolevn/recase) helps you to convert a string
from any case to any case.
* [ProperCase](https://github.com/johnnyji/proper_case) an Elixir library that
converts keys in maps between snake_case and camel_case.
"""
@underscore ?_
@hyphen ?-
@separator [@underscore, @hyphen]
defguardp is_upper(char) when char >= ?A and char <= ?Z
defguardp is_lower(char) when not (char >= ?A and char <= ?Z)
defguardp is_separator(char) when char in @separator
@doc """
Converts `camelCase` and `kebab-case` into `snake_case`.
For strings, the function returns the converted string.
## Examples
iex> ConvCase.to_snake_case("fooBar")
"foo_bar"
iex> ConvCase.to_snake_case("foo-bar")
"foo_bar"
For atoms, the function returns the converted atom.
`String.to_existing_atom/1` is used to create "new" atoms.
iex> ConvCase.to_snake_case(:fooBar)
:foo_bar
For lists, the function returns a list with converted values.
iex> ConvCase.to_snake_case(["fooBar", "foo-bar"])
["foo_bar", "foo_bar"]
For tuples, the function returns a tuple with converted values.
iex> ConvCase.to_snake_case({"fooBar", "foo-bar"})
{"foo_bar", "foo_bar"}
For maps, the function returns a map with converted keys. The type of the key
will not be changed. New atoms are generated by `String.to_existing_atom/1`.
The keys of nested maps are also converted.
iex> ConvCase.to_snake_case(%{fooBar: %{"foo-bar" => "foo-bar"}})
%{foo_bar: %{"foo_bar" => "foo-bar"}}
For other types, the function returns the given value.
iex> ConvCase.to_snake_case(42)
42
"""
@spec to_snake_case(any) :: any
def to_snake_case(string)
def to_snake_case(""), do: ""
def to_snake_case(atom)
when is_atom(atom),
do:
atom
|> Atom.to_string()
|> to_snake_case()
|> String.to_existing_atom()
def to_snake_case(strings)
when is_list(strings),
do: Enum.map(strings, &to_snake_case/1)
def to_snake_case(tuple)
when is_tuple(tuple),
do:
tuple
|> Tuple.to_list()
|> Enum.map(&to_snake_case/1)
|> List.to_tuple()
def to_snake_case(map)
when is_map(map),
do: convert_map(map, &to_snake_case/1)
def to_snake_case(<<a, b, t::binary>>)
when is_upper(a) and is_lower(b),
do: <<to_lower(a), b>> <> do_to_separator_case(t, @underscore)
def to_snake_case(string)
when is_binary(string),
do: do_to_separator_case(string, @underscore)
def to_snake_case(any), do: any
@doc """
Converts `snake_case` and `kebab-case` into `camelCase`.
For strings, the function returns the converted string.
## Examples
iex> ConvCase.to_camel_case("foo_bar")
"fooBar"
iex> ConvCase.to_camel_case("foo-bar")
"fooBar"
For atoms, the function returns the converted atom. This function used
`String.to_existing_atom/1`.
## Examples
iex> ConvCase.to_camel_case(:foo_bar)
:fooBar
For lists, the function returns a list with converted values.
## Examples
iex> ConvCase.to_camel_case(["foo_bar", "foo-bar"])
["fooBar", "fooBar"]
For tuples, the function returns a tuple with converted values.
## Examples
iex> ConvCase.to_camel_case({"foo_bar", "foo-bar"})
{"fooBar", "fooBar"}
For maps, the function returns a map with converted keys. The type of the key
will not be changed. New atoms are generated by `String.to_existing_atom/1`.
Keys of nested maps are converted too.
## Examples
iex> ConvCase.to_camel_case(%{foo_bar: %{"foo-bar" => "foo-bar"}})
%{fooBar: %{"fooBar" => "foo-bar"}}
For other types, the function returns the given value.
## Examples
iex> ConvCase.to_camel_case(42)
42
"""
@spec to_camel_case(any) :: any
def to_camel_case(value)
def to_camel_case(""), do: ""
def to_camel_case(atom)
when is_atom(atom),
do:
atom
|> Atom.to_string()
|> to_camel_case()
|> String.to_existing_atom()
def to_camel_case(strings)
when is_list(strings),
do: Enum.map(strings, &to_camel_case/1)
def to_camel_case(tuple)
when is_tuple(tuple),
do:
tuple
|> Tuple.to_list()
|> Enum.map(&to_camel_case/1)
|> List.to_tuple()
def to_camel_case(map)
when is_map(map),
do: convert_map(map, &to_camel_case/1)
def to_camel_case(<<a, b, t::binary>>)
when is_separator(a),
do: <<to_upper(b)>> <> to_camel_case(t)
def to_camel_case(<<h, t::binary>>), do: <<h>> <> to_camel_case(t)
def to_camel_case(any), do: any
@doc """
Converts `snake_case` and `camelCase` into `kebab-case`.
For strings, the function returns the converted string.
## Examples
iex> ConvCase.to_kebab_case("foo_bar")
"foo-bar"
iex> ConvCase.to_kebab_case("fooBar")
"foo-bar"
For atoms, the function returns the converted atom. This function used
`String.to_existing_atom/1`.
## Examples
iex> ConvCase.to_kebab_case(:foo_bar)
:"foo-bar"
For lists, the function returns a list with converted values.
## Examples
iex> ConvCase.to_kebab_case(["foo_bar", "fooBar"])
["foo-bar", "foo-bar"]
For tuples, the function returns a tuple with converted values.
## Examples
iex> ConvCase.to_kebab_case({"foo_bar", "fooBar"})
{"foo-bar", "foo-bar"}
For maps, the function returns a map with converted keys. The type of the key
will not be changed. New atoms are generated by `String.to_existing_atom/1`.
Keys of nested maps are converted too.
## Examples
iex> ConvCase.to_kebab_case(%{foo_bar: %{"fooBar" => "fooBar"}})
%{"foo-bar": %{"foo-bar" => "fooBar"}}
For other types, the function returns the given value.
## Examples
iex> ConvCase.to_kebab_case(42)
42
"""
@spec to_kebab_case(any) :: any
def to_kebab_case(value)
def to_kebab_case(""), do: ""
def to_kebab_case(atom)
when is_atom(atom),
do:
atom
|> Atom.to_string()
|> to_kebab_case()
|> String.to_existing_atom()
def to_kebab_case(strings)
when is_list(strings),
do: Enum.map(strings, &to_kebab_case/1)
def to_kebab_case(tuple)
when is_tuple(tuple),
do:
tuple
|> Tuple.to_list()
|> Enum.map(&to_kebab_case/1)
|> List.to_tuple()
def to_kebab_case(map)
when is_map(map),
do: convert_map(map, &to_kebab_case/1)
def to_kebab_case(<<a, b, t::binary>>)
when is_upper(a) and is_lower(b),
do: <<to_lower(a), b>> <> do_to_separator_case(t, @hyphen)
def to_kebab_case(string)
when is_binary(string),
do: do_to_separator_case(string, @hyphen)
def to_kebab_case(any), do: any
# Convert string with given separator.
defp do_to_separator_case("", _separator), do: ""
defp do_to_separator_case(<<h, t::binary>>, separator)
when is_separator(h),
do: <<separator>> <> do_to_separator_case(t, separator)
defp do_to_separator_case(<<a, b, t::binary>>, separator)
when is_lower(a) and is_upper(b),
do: <<a, separator, to_lower(b)>> <> do_to_separator_case(t, separator)
defp do_to_separator_case(<<h, t::binary>>, separator),
do: <<h>> <> do_to_separator_case(t, separator)
# Convert map keys with the given converter.
defp convert_map(%{__struct__: _} = struct, _), do: struct
defp convert_map(map, converter) when is_map(map) do
for {key, value} <- map,
into: %{},
do: {convert_key(key, converter), convert_map(value, converter)}
end
defp convert_map(list, converter)
when is_list(list),
do: Enum.map(list, &convert_map(&1, converter))
defp convert_map(map, _converter), do: map
# Convert key with the given converter.
defp convert_key(key, converter)
when is_atom(key),
do: key |> converter.()
defp convert_key(key, converter), do: converter.(key)
# Convert a lowercase character into an uppercase character.
defp to_upper(char), do: char - 32
# Convert an uppercase character into a lowercase character.
defp to_lower(char), do: char + 32
end
