Allow only non-empty brackets/braces

We'd like to disallow brackets and braces in our YAML, but there's a
catch: the only way to describe an empty array or hash in YAML is to
supply an empty one (`[]` or `{}`). Otherwise, the value will be null.

This commit adds a `non-empty` option to `forbid` for brackets and
braces. When it is set, all flow and sequence mappings will cause errors
_except_ for empty ones.

tests/rules/test_braces.py

@@ -61,6 +61,22 @@ class ColonTestCase(RuleTestCase):
                    '  a: 1\n'
                    '}\n', conf, problem=(2, 8))
 
+        conf = ('braces:\n'
+                '  forbid: non-empty\n')
+        self.check('---\n'
+                   'dict:\n'
+                   '  a: 1\n', conf)
+        self.check('---\n'
+                   'dict: {}\n', conf)
+        self.check('---\n'
+                   'dict: {a}\n', conf, problem=(2, 8))
+        self.check('---\n'
+                   'dict: {a: 1}\n', conf, problem=(2, 8))
+        self.check('---\n'
+                   'dict: {\n'
+                   '  a: 1\n'
+                   '}\n', conf, problem=(2, 8))
+
     def test_min_spaces(self):
         conf = ('braces:\n'
                 '  max-spaces-inside: -1\n'

tests/rules/test_brackets.py

@@ -60,6 +60,22 @@ class ColonTestCase(RuleTestCase):
                    '  b\n'
                    ']\n', conf, problem=(2, 9))
 
+        conf = ('brackets:\n'
+                '  forbid: non-empty\n')
+        self.check('---\n'
+                   'array:\n'
+                   '  - a\n'
+                   '  - b\n', conf)
+        self.check('---\n'
+                   'array: []\n', conf)
+        self.check('---\n'
+                   'array: [a, b]\n', conf, problem=(2, 9))
+        self.check('---\n'
+                   'array: [\n'
+                   '  a,\n'
+                   '  b\n'
+                   ']\n', conf, problem=(2, 9))
+
     def test_min_spaces(self):
         conf = ('brackets:\n'
                 '  max-spaces-inside: -1\n'

yamllint/rules/braces.py

@@ -22,7 +22,8 @@ braces (``{`` and ``}``).
 
 * ``forbid`` is used to forbid the use of flow mappings which are denoted by
   surrounding braces (``{`` and ``}``). Use ``true`` to forbid the use of flow
-  mappings completely.
+  mappings completely. Use ``non-empty`` to forbid the use of all flow
+  mappings except for empty ones.
 * ``min-spaces-inside`` defines the minimal number of spaces required inside
   braces.
 * ``max-spaces-inside`` defines the maximal number of spaces allowed inside
@@ -60,6 +61,18 @@ braces (``{`` and ``}``).
 
     object: { key1: 4, key2: 8 }
 
+#. With ``braces: {forbid: non-empty}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    object: {}
+
+   the following code snippet would **FAIL**:
+   ::
+
+    object: { key1: 4, key2: 8 }
+
 #. With ``braces: {min-spaces-inside: 0, max-spaces-inside: 0}``
 
    the following code snippet would **PASS**:
@@ -128,7 +141,7 @@ from yamllint.rules.common import spaces_after, spaces_before
 
 ID = 'braces'
 TYPE = 'token'
-CONF = {'forbid': bool,
+CONF = {'forbid': (bool, 'non-empty'),
         'min-spaces-inside': int,
         'max-spaces-inside': int,
         'min-spaces-inside-empty': int,
@@ -141,7 +154,14 @@ DEFAULT = {'forbid': False,
 
 
 def check(conf, token, prev, next, nextnext, context):
-    if conf['forbid'] and isinstance(token, yaml.FlowMappingStartToken):
+    if conf['forbid'] == True and isinstance(token, yaml.FlowMappingStartToken):
+        yield LintProblem(token.start_mark.line + 1,
+                          token.end_mark.column + 1,
+                          'forbidden flow mapping')
+
+    elif (conf['forbid'] == 'non-empty' and
+      isinstance(token, yaml.FlowMappingStartToken) and
+      not isinstance(next, yaml.FlowMappingEndToken)):
         yield LintProblem(token.start_mark.line + 1,
                           token.end_mark.column + 1,
                           'forbidden flow mapping')

yamllint/rules/brackets.py

@@ -22,7 +22,8 @@ inside brackets (``[`` and ``]``).
 
 * ``forbid`` is used to forbid the use of flow sequences which are denoted by
   surrounding brackets (``[`` and ``]``). Use ``true`` to forbid the use of
-  flow sequences completely.
+  flow sequences completely. Use ``non-empty`` to forbid the use of all flow
+  sequences except for empty ones.
 * ``min-spaces-inside`` defines the minimal number of spaces required inside
   brackets.
 * ``max-spaces-inside`` defines the maximal number of spaces allowed inside
@@ -61,6 +62,18 @@ inside brackets (``[`` and ``]``).
 
     object: [ 1, 2, abc ]
 
+#. With ``brackets: {forbid: non-empty}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    object: []
+
+   the following code snippet would **FAIL**:
+   ::
+
+    object: [ 1, 2, abc ]
+
 #. With ``brackets: {min-spaces-inside: 0, max-spaces-inside: 0}``
 
    the following code snippet would **PASS**:
@@ -129,7 +142,7 @@ from yamllint.rules.common import spaces_after, spaces_before
 
 ID = 'brackets'
 TYPE = 'token'
-CONF = {'forbid': bool,
+CONF = {'forbid': (bool, 'non-empty'),
         'min-spaces-inside': int,
         'max-spaces-inside': int,
         'min-spaces-inside-empty': int,
@@ -142,7 +155,14 @@ DEFAULT = {'forbid': False,
 
 
 def check(conf, token, prev, next, nextnext, context):
-    if conf['forbid'] and isinstance(token, yaml.FlowSequenceStartToken):
+    if conf['forbid'] == True and isinstance(token, yaml.FlowSequenceStartToken):
+        yield LintProblem(token.start_mark.line + 1,
+                          token.end_mark.column + 1,
+                          'forbidden flow sequence')
+
+    elif (conf['forbid'] == 'non-empty' and
+      isinstance(token, yaml.FlowSequenceStartToken) and
+      not isinstance(next, yaml.FlowSequenceEndToken)):
         yield LintProblem(token.start_mark.line + 1,
                           token.end_mark.column + 1,
                           'forbidden flow sequence')