Rename all map keys

Hi! I have a list of maps and I want to rename the keys.

What I have:

[info] entities: [ok: %{"Email Address [Required]" => "fblue@mikasa.com", "First Name [Required]" => "Blue", "Last Name [Required]" => "First"}, ok: %{"Email Address [Required]" => "sred@mikasa.com", "First Name [Required]" => "Red", "Last Name [Required]" => "Second"}, ok: %{"Email Address [Required]" => "tyellow@mikasa.com", "First Name [Required]" => "Yellow", "Last Name [Required]" => "Third"}]

What I want to achieve:

[info] entities: [ok: %{"email" => "fblue@mikasa.com", "first_name" => "Blue", "last_name" => "First"}, ok: %{"email" => "sred@mikasa.com", "first_name" => "Red", "last_name" => "Second"}, ok: %{"email" => "tyellow@mikasa.com", "first_name" => "Yellow", "last_name" => "Third"}]

First Name [Required] to first_name
Last Name [Required] to last_name
Email Address [Required] to email

I am not sure how will I work on the keys with all the white space and the [] brackets.

You might remove [Required] with String.replace + trim. You might even transform “LastName” to “last_name” with Macro.underscore.

But how do You want him to translate “Email Address” to “email”?

Unless You use some custom rules…

2 Likes

for "Last Name [Required]" → "last_name"

key |> String.trim(" [Required]") |> String.downcase() |> String.replace(" ", "_")

for "Email Address [Required]" → "email", you might just pattern match on the special case in a multiple function clause

defp rename_key({"Email Address [Required]", val}), do: {"email", val}
defp rename_key({key, val}) do
  # operate on the key
  {new_key, val}
end
2 Likes

Here is a complete code:

defmodule Example do
  # First of all we call map on our keyword
  def sample(keyword) when is_list(keyword), do: Enum.map(keyword, &rename/1)

  # When key is ok atom and value is a map call rename function
  defp rename({key = :ok, map}) when is_map(map), do: {key, rename(map)}

  # Rename for maps is using for comprehension changing only key and keeping value as is
  defp rename(map) when is_map(map) do
    for {key, value} <- map, into: %{}, do: {rename(key), value}
  end

  # Rename for binary is removing trailing string and calling rename_key
  defp rename(binary) when is_binary(binary) do
    binary |> String.trim_trailing(" [Required]") |> rename_key()
  end

  # A simple pattern-match in rename_key for a special email case
  defp rename_key("Email Address"), do: "email"

  # rename_key for any other string
  defp rename_key(key) when is_binary(key) do
    key |> String.replace(" ", "") |> Macro.underscore()
  end
end

expected_output = [
  ok: %{
    "email" => "fblue@mikasa.com",
    "first_name" => "Blue",
    "last_name" => "First"
  },
  ok: %{
    "email" => "sred@mikasa.com",
    "first_name" => "Red",
    "last_name" => "Second"
  },
  ok: %{
    "email" => "tyellow@mikasa.com",
    "first_name" => "Yellow",
    "last_name" => "Third"
  }
]

input = [
  ok: %{
    "Email Address [Required]" => "fblue@mikasa.com",
    "First Name [Required]" => "Blue",
    "Last Name [Required]" => "First"
  },
  ok: %{
    "Email Address [Required]" => "sred@mikasa.com",
    "First Name [Required]" => "Red",
    "Last Name [Required]" => "Second"
  },
  ok: %{
    "Email Address [Required]" => "tyellow@mikasa.com",
    "First Name [Required]" => "Yellow",
    "Last Name [Required]" => "Third"
  }
]

result = Example.sample(input)
IO.puts(result == expected_output)
# true

Helpful resources:

  1. Kernel.is_list/1
  2. Kernel.is_map/1
  3. Enum.map/2
  4. Kernel.SpecialForms.for/1
  5. String.replace/4
  6. String.trim_trailing/2
  7. Macro.underscore/1
  8. Patterns and Guards
4 Likes

The simplest way to accomplish what you’ve written is to look up replacement keys in a supplied map. For instance:

defmodule KeyRenamer do
  @key_replacements %{
    "First Name [Required]" => "first_name",
    "Last Name [Required]" => "last_name",
    "Email Address [Required]" => "email"
  }

  def rename_keys(map) do
    Map.new(map, fn k, v ->
      new_key = Map.get(@key_replacements, k, k)
      {new_key, v}
    end
  end
end

An alternative approach would be to fix the code that’s generating these keys - for instance, if it’s extracting a value from an HTML label maybe it should be using the input's name or something instead…

5 Likes

If the keys are known and static, and you don’t need to make this logic reusable, you could also use plain pattern-matching:

  def rename_keys(%{
    "First Name [Required]" => first_name,
    "Last Name [Required]" => last_name,
    "Email Address [Required]" => email
  }) do
    %{first_name: first_name, last_name: last_name, email: email}
  end
4 Likes