function isException(node, parent, exceptions) {
            var grandpa = parent.parentElement;

            // Check if this block is used in call or array expression
            if (grandpa && exceptions[grandpa.type]) {
                return true;
            }

            var first = node.getFirstToken();
            var last = node.getLastToken();

            if (exceptions.SingleLine && file.isOnTheSameLine(first, last)) {
                return true;
            }

            return false;
        }
Requires newline after blocks

Type: `Boolean` or `Object`

Values:
- `true`: always require a newline after blocks
- `Object`:
     - `"allExcept"`: `Array`
         - `"inCallExpressions"` Blocks don't need a line of padding in function argument lists
         - `"inNewExpressions"` Blocks don't need a line of padding in constructor argument lists
         - `"inArrayExpressions"` Blocks don't need a line of padding in arrays
         - `"inProperties"` Blocks don't need a line of padding as object properties
         - `"singleLine"` Blocks don't need a line of padding if they are on a single line

#### Example

```js
"requirePaddingNewLinesAfterBlocks": true
"requirePaddingNewLinesAfterBlocks": {
    "allExcept": ["inCallExpressions", "inNewExpressions", "inArrayExpressions", "inProperties", "singleLine"]
}
```

##### Valid

```js
function () {
    for (var i = 0; i < 2; i++) {
        if (true) {
            return false;
        }

        continue;
    }

    var obj = {
        foo: function() {
            return 1;
        },

        bar: function() {
            return 2;
        }
    };

    func(
         function() {
         }
    );

    var a = [
        function() {
        },

        function() {
        }
    ]

}
```

##### Valid for `{ "allExcept": ["inCallExpressions"] }`

```js
func(
    2,
    3,
    function() {
    }
);
```

##### Valid for `{ "allExcept": ["inNewExpressions"] }`

```js
new SomeClass(
    2,
    3,
    function() {
    }
);
```

##### Valid for `{ "allExcept": ["inArrayExpressions"] }`

```js
var foo = [
    2,
    3,
    function() {
    }
];
```
##### Valid for `{ "allExcept": ["inProperties"] }`

```js
var foo = {
    a: 2,
    b: function() {
    },
    c: 3
];
```
##### Valid for `{ "allExcept": ["singleLine"] }`
```js
for (var i = 0; i < 10; ++i) {
    if (i % 2 === 0) { continue; }
    console.log('Its getting odd in here...');
}
```

##### Invalid

```js
function () {
    for (var i = 0; i < 2; i++) {
        if (true) {
            return false;
        }
        continue;
    }
}
```