jeremywohl / flatten

Flatten nested maps or JSON structures to one-dimensional scalar sets.

flatten

Note: development continues in v2

Flatten makes flat, one-dimensional maps from arbitrarily nested ones.

It turns map keys into compound names, in four default styles: dotted (a.b.1.c), path-like (a/b/1/c), Rails (a[b][1][c]), or with underscores (a_b_1_c). Alternatively, you can pass a custom style.

It takes input as either JSON strings or Go structures. It knows how to traverse these JSON types: objects/maps, arrays and scalars.

You can flatten JSON strings.

nested := `{
  "one": {
    "two": [
      "2a",
      "2b"
    ]
  },
  "side": "value"
}`

flat, err := flatten.FlattenString(nested, "", flatten.DotStyle)

// output: `{ "one.two.0": "2a", "one.two.1": "2b", "side": "value" }`

Or Go maps directly.

nested := map[string]interface{}{
   "a": "b",
   "c": map[string]interface{}{
       "d": "e",
       "f": "g",
   },
   "z": 1.4567,
}

flat, err := flatten.Flatten(nested, "", flatten.RailsStyle)

// output:
// map[string]interface{}{
//  "a":    "b",
//  "c[d]": "e",
//  "c[f]": "g",
//  "z":    1.4567,
// }

Let's try a custom style, with the first example above.

emdash := flatten.SeparatorStyle{Middle: "--"}
flat, err := flatten.FlattenString(nested, "", emdash)

// output: `{ "one--two--0": "2a", "one--two--1": "2b", "side": "value" }`

See godoc for API.

flatten's Issues

Flattened map is un-order

Hi all,

Is there any option to keep the order of Flattned Map same with origion JSON string ?

Support for unflattening (e.g. reverse operation)

Hi,

Nice library! Have you considered adding support for reversing, i.e. unflattening? If I slightly change the example in the README:

input := `{ "one.two.0": "2a", "one.two.1": "2b", "side": "value" }`
nested, err := flatten.UnflattenString(input, "", flatten.DotStyle)

/*
nested == {
  "one": {
    "two": [
      "2a",
      "2b"
    ]
  },
  "side": "value"
}
*/

lost empty array

input:

{
  "a": [],
  "b": 1
}

want:

{"a": [], "b": 1}

but got:

{"b": 1}

[Feature Request] Allow distinguishing between lists and objects

It might be nice to support flattened paths that distinguish between list indexes and object keys.

E.g., this:

{
  "foo": {
    "0": ["bar", {"baz": "bam"}],
  }
}

might be flattened to:

{
  "foo.0[0]": "bar",
  "foo.0[1].baz": "bam",
}

Passing "null" to FlattenString outputs empty JSON object instead of error

See following example:

	flat, err := flatten.FlattenString("null", "", flatten.DotStyle)
	fmt.Printf("error: %v\n", err)
	fmt.Printf("v: %s\n", flat)

	flat, err = flatten.FlattenString("a", "", flatten.DotStyle)
	fmt.Printf("error: %v\n", err)
	fmt.Printf("v: %s\n", flat)

https://play.golang.org/p/AKQWQcY_VA6

String literal value is provided in both examples ("null" and "a"). We got no error for the first case with {} value as an output where for the second example the output spawns the error.

I would expect an error.

I know this is an edge case and both behaviors are acceptable. I propose to at least add a test for it. I am happy to contribute once it's clear what to do.

leave string array/ int array as raw

input:

{
  "a": {
    "b": [1, 2, 3]
  }
}

output:
{"a.b": [1, 2, 3]}

Inconsistent behaviour of list flattening

Why are lists flattened for FlattenString but not for Flatten?

Example (Try on go playground):

package main

import (
	"fmt"
	"github.com/jeremywohl/flatten"
)

func main() {
	nested_json := `{
  "one": {
    "two": [
      "2a",
      "2b"
    ],
    "three": []
  },
  "side": "value"
}`

	flat_json, _ := flatten.FlattenString(nested_json, "", flatten.DotStyle)
	fmt.Println(flat_json)

	nested_map := map[string]interface{}{
		"one": map[string]interface{}{
			"two":   []string{"a", "b"},
			"three": []string{},
		},
		"side": "value",
	}
	flat_map, _ := flatten.Flatten(nested_map, "", flatten.DotStyle)
	fmt.Println(flat_map)
}

Results:

{"one.two.0":"2a","one.two.1":"2b","side":"value"}
map[one.three:[] one.two:[a b] side:value]