.gitignore

@@ -1 +1,2 @@
 node_modules
+.idea

.travis.yml

@@ -1,4 +1,8 @@
 language: node_js
 node_js:
-  - 0.6
-  - 0.8
+  - "6"
+  - "7"
+  - "8"
+  - "10"
+  - "12"
+  - "14"

README.md

@@ -122,7 +122,7 @@ When enabled, existing keys in the unflattened object may be overwritten if they
 ```javascript
 unflatten({
     'TRAVIS': 'true',
-    'TRAVIS_DIR': '/home/travis/build/kvz/environmental'
+    'TRAVIS.DIR': '/home/travis/build/kvz/environmental'
 }, { overwrite: true })
 
 // TRAVIS: {
@@ -158,3 +158,79 @@ flatten({
 //   'key3.a': { b: { c: 2 } }
 // }
 ```
+
+### transformKey
+
+Transform each part of a flat key before and after flattening.
+
+```javascript
+var flatten = require('flat')
+var unflatten = require('flat').unflatten
+
+flatten({
+    key1: {
+        keyA: 'valueI'
+    },
+    key2: {
+        keyB: 'valueII'
+    },
+    key3: { a: { b: { c: 2 } } }
+}, {
+    transformKey: function(key){
+      return '__' + key + '__';
+    }
+})
+
+// {
+//   '__key1__.__keyA__': 'valueI',
+//   '__key2__.__keyB__': 'valueII',
+//   '__key3__.__a__.__b__.__c__': 2
+// }
+
+unflatten({
+      '__key1__.__keyA__': 'valueI',
+      '__key2__.__keyB__': 'valueII',
+      '__key3__.__a__.__b__.__c__': 2
+}, {
+    transformKey: function(key){
+      return key.substring(2, key.length - 2)
+    }
+})
+
+// {
+//     key1: {
+//         keyA: 'valueI'
+//     },
+//     key2: {
+//         keyB: 'valueII'
+//     },
+//     key3: { a: { b: { c: 2 } } }
+// }
+```
+
+## Command Line Usage
+
+`flat` is also available as a command line tool. You can run it with 
+[`npx`](https://ghub.io/npx):
+
+```sh
+npx flat foo.json
+```
+
+Or install the `flat` command globally:
+
+```sh
+npm i -g flat && flat foo.json
+```
+
+Accepts a filename as an argument:
+
+```sh
+flat foo.json
+```
+
+Also accepts JSON on stdin:
+
+```sh
+cat foo.json | flat
+```

cli.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+const readline = require('readline')
+
+const flat = require('./index')
+
+const filepath = process.argv.slice(2)[0]
+if (filepath) {
+  // Read from file
+  const file = path.resolve(process.cwd(), filepath)
+  fs.accessSync(file, fs.constants.R_OK) // allow to throw if not readable
+  out(require(file))
+} else if (process.stdin.isTTY) {
+  usage(0)
+} else {
+  // Read from newline-delimited STDIN
+  const lines = []
+  readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  })
+    .on('line', line => lines.push(line))
+    .on('close', () => out(JSON.parse(lines.join('\n'))))
+}
+
+function out (data) {
+  process.stdout.write(JSON.stringify(flat(data), null, 2))
+}
+
+function usage (code) {
+  console.log(`
+Usage:
+
+flat foo.json
+cat foo.json | flat
+`)
+
+  process.exit(code || 0)
+}

index.js

@@ -1,31 +1,41 @@
-var isBuffer = require('is-buffer')
-
-var flat = module.exports = flatten
+module.exports = flatten
 flatten.flatten = flatten
 flatten.unflatten = unflatten
 
-function flatten(target, opts) {
+function isBuffer (obj) {
+  return obj &&
+    obj.constructor &&
+    (typeof obj.constructor.isBuffer === 'function') &&
+    obj.constructor.isBuffer(obj)
+}
+
+function keyIdentity (key) {
+  return key
+}
+
+function flatten (target, opts) {
   opts = opts || {}
 
-  var delimiter = opts.delimiter || '.'
-  var maxDepth = opts.maxDepth
-  var output = {}
-
-  function step(object, prev, currentDepth) {
-    currentDepth = currentDepth ? currentDepth : 1
-    Object.keys(object).forEach(function(key) {
-      var value = object[key]
-      var isarray = opts.safe && Array.isArray(value)
-      var type = Object.prototype.toString.call(value)
-      var isbuffer = isBuffer(value)
-      var isobject = (
-        type === "[object Object]" ||
-        type === "[object Array]"
+  const delimiter = opts.delimiter || '.'
+  const maxDepth = opts.maxDepth
+  const transformKey = opts.transformKey || keyIdentity
+  const output = {}
+
+  function step (object, prev, currentDepth) {
+    currentDepth = currentDepth || 1
+    Object.keys(object).forEach(function (key) {
+      const value = object[key]
+      const isarray = opts.safe && Array.isArray(value)
+      const type = Object.prototype.toString.call(value)
+      const isbuffer = isBuffer(value)
+      const isobject = (
+        type === '[object Object]' ||
+        type === '[object Array]'
       )
 
-      var newKey = prev
-        ? prev + delimiter + key
-        : key
+      const newKey = prev
+        ? prev + delimiter + transformKey(key)
+        : transformKey(key)
 
       if (!isarray && !isbuffer && isobject && Object.keys(value).length &&
         (!opts.maxDepth || currentDepth < maxDepth)) {
@@ -41,41 +51,84 @@ function flatten(target, opts) {
   return output
 }
 
-function unflatten(target, opts) {
+function unflatten (target, opts) {
   opts = opts || {}
 
-  var delimiter = opts.delimiter || '.'
-  var overwrite = opts.overwrite || false
-  var result = {}
+  const delimiter = opts.delimiter || '.'
+  const overwrite = opts.overwrite || false
+  const transformKey = opts.transformKey || keyIdentity
+  const result = {}
 
-  var isbuffer = isBuffer(target)
+  const isbuffer = isBuffer(target)
   if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') {
     return target
   }
 
   // safely ensure that the key is
   // an integer.
-  function getkey(key) {
-    var parsedKey = Number(key)
+  function getkey (key) {
+    const parsedKey = Number(key)
 
     return (
       isNaN(parsedKey) ||
-      key.indexOf('.') !== -1
+      key.indexOf('.') !== -1 ||
+      opts.object
     ) ? key
       : parsedKey
   }
 
-  Object.keys(target).forEach(function(key) {
-    var split = key.split(delimiter)
-    var key1 = getkey(split.shift())
-    var key2 = getkey(split[0])
-    var recipient = result
+  function addKeys (keyPrefix, recipient, target) {
+    return Object.keys(target).reduce(function (result, key) {
+      result[keyPrefix + delimiter + key] = target[key]
+
+      return result
+    }, recipient)
+  }
+
+  function isEmpty (val) {
+    const type = Object.prototype.toString.call(val)
+    const isArray = type === '[object Array]'
+    const isObject = type === '[object Object]'
+
+    if (!val) {
+      return true
+    } else if (isArray) {
+      return !val.length
+    } else if (isObject) {
+      return !Object.keys(val).length
+    }
+  }
+
+  target = Object.keys(target).reduce(function (result, key) {
+    const type = Object.prototype.toString.call(target[key])
+    const isObject = (type === '[object Object]' || type === '[object Array]')
+    if (!isObject || isEmpty(target[key])) {
+      result[key] = target[key]
+      return result
+    } else {
+      return addKeys(
+        key,
+        result,
+        flatten(target[key], opts)
+      )
+    }
+  }, {})
+
+  Object.keys(target).forEach(function (key) {
+    const split = key.split(delimiter).map(transformKey)
+    let key1 = getkey(split.shift())
+    let key2 = getkey(split[0])
+    let recipient = result
 
     while (key2 !== undefined) {
-      var type = Object.prototype.toString.call(recipient[key1])
-      var isobject = (
-        type === "[object Object]" ||
-        type === "[object Array]"
+      if (key1 === '__proto__') {
+        return
+      }
+
+      const type = Object.prototype.toString.call(recipient[key1])
+      const isobject = (
+        type === '[object Object]' ||
+        type === '[object Array]'
       )
 
       // do not write over falsey, non-undefined values if overwrite is false