Recursively traverse and update nested map

Questions / Help
,
1

I have the following data structure:

data = %{
  "foo" => "bar",
  "abc" => %{
    "source" => "my-id",
    "value" => "12345"
  },
  "list" => [
    %{"source" => "my-id", "value" => "56789"},
    %{"source" => "my-other-id", "value" => "hello"}
  ]
}

I want to replace the inner maps that match the supplied source_id and replace them with a default value of %{"source" => "", "value" => ""}
If the matched map was is a list, then it should be removed (if it‘s a top level item in that list).

So if I call cleanup(data, "my-id"), the expected output should be:

%{
  "foo" => "bar",
  "abc" => %{
    "source" => "",
    "value" => ""
  },
  "list" => [
    %{"source" => "my-other-id", "value" => "hello"}
  ]
}

Should support any level of nesting. Having a bit of a brain freeze how to do it in an elegant way.

Please help with any pointers.

2

Not sure if this is elegant, but this one way of doing it

defmodule Example do
  def cleanup(data, source) when is_map(data) do
    if filter?(data, source) do
      %{"source" => "", "value" => ""}
    else
      Map.new(data, fn {key, value} ->
        {key, cleanup(value, source)}
      end)
    end
  end

  def cleanup([hd | tail], source) do
    list = if filter?(hd, source), do: tail, else: [hd | tail]
    Enum.map(list, &cleanup(&1, source))
  end

  def cleanup(data, _source), do: data

  defp filter?(data, source), do: match?(%{"source" => ^source}, data)
end
2 Likes
3

Is it possible to change the data structure?

Some points that would make me think twice are

  • arbitrary keys (Most of the time I’d prefer %{key: "foo", value: "bar"} over %{foo: "bar"})
  • maps may occur in lists and as single item (why not lists of one instead?)
  • nested structure, most of the times a flat structure is easier to handle

Its impossible to say if that would be better not knowing what you are doing. But I found that thinking twice about the data structures can lead to way simpler code.

1 Like
4

This is a fairly elegant solution, IMO:

defmodule Cleanup do
  def cleanup(data, source_id) do
    case data do
      %{"source" => ^source_id} ->
        %{"source" => "", "value" => ""}

      %{} ->
        Map.new(data, fn {k, v} -> {k, cleanup(v, source_id)} end)

      [_ | _] ->
        data
        |> Enum.reject(&match?(%{"source" => ^source_id}, &1))
        |> Enum.map(fn v -> cleanup(v, source_id) end)

      _ ->
        data
    end
  end
end

Just like the data structure, the code is recursive (for handling list elements and child maps).

The most unique part of this is the middle line in the list case:

Enum.reject(data, &match?(%{"source" => ^source_id}, &1))

Without that line, cleanup simply replaces every map with `“source” => ^source_id" with the empty version

2 Likes
5

@akash-akya @al2o3cr Very cool. I see some similar ideas, will try it out. Thanks you both. I was also thinking about giving Pathex a try, but your solutions are much easier to understand.

@Sebb Unfortunately the data shape is out of my control. It’s an arbitrary external JSON without any standard shape, that represents params that need to be passed to another endpoint.