Transforming the name of key deeper in the JSON structure with jq

Question

I have following json:

{
  \"vertices\": [
    {
      \"__cp\": \"foo\",
      \"__type\": \"metric\",
      \"__eid\": \"foobar\",
      \"name\": \"Undert         


        

Answer 1

You can change the names of properties of objects if you use with_entries(filter). This converts an object to an array of key/value pairs and applies a filter to the pairs and converts back to an object. So you would just want to update the key of those objects to your new names.

Depending on which version of jq you're using, the next part can be tricky. String replacement doesn't get introduced until jq 1.5. If that was available, you could then do this:

{
    nodes: .vertices | map(with_entries(
        .key |= sub("^_+"; "")
    )),
    edges
}

Otherwise if you're using jq 1.4, then you'll have to remove them manually. A recursive function can help with that since the number of underscores varies.

def ltrimall(str): str as $str |
    if startswith($str)
        then ltrimstr($str) | ltrimall(str)
        else .
    end;
{
    nodes: .vertices | map(with_entries(
        .key |= ltrimall("_")
    )),
    edges
}

Answer 2

From your example data it looks like you intend lots of little manipulations so I'd break things out into stages like this:

  .nodes = .vertices                     # \ first take care of renaming
| del(.vertices)                         # / .vertices to .nodes

| .nodes = [ 
       .nodes[]                          # \ then scan each node
     | . as $n                           # /

     | del(._type, .__eid)               # \ whatever key-specific tweaks like 
     | .label = "metric: \(.name)"       # / calculating .label you want can go here

     | reduce keys[] as $k (             # \
         {};                             # | final reduce to handle renaming
         .[$k | sub("^_+";"")] = $n[$k]  # | any keys that start with _
       )                                 # /
  ]

Answer 3

The following program works with jq 1.4 or jq 1.5. It uses walk/1 to remove leading underscores from any key, no matter where it occurs in the input JSON.

The version of ltrim provided here uses recurse/1 for efficiency and portability, but any suitable substitute may be used.

def ltrim(c):
  reduce recurse( if .[0:1] == c then .[1:] else null end) as $x 
    (null; $x);

# Apply f to composite entities recursively, and to atoms
def walk(f):
 . as $in
 | if type == "object" then
      reduce keys[] as $key
        ( {}; . + { ($key):  ($in[$key] | walk(f)) } ) | f
  elif type == "array" then map( walk(f) ) | f
  else f
  end;

.vertices = .nodes
| del(.nodes)
| (.vertices |= walk(
      if type == "object"
      then with_entries( .key |= ltrim("_") )
      else .
      end ))