yamllint version 1.0.2

Distribution: Add MANIFEST.in
`yamllint/conf/*.yml` remains in `setup.py`'s `package_data` because it needs to be installed when running `pip install .`. `docs/*` and `tests/yaml-1.2-spec-examples/*` just need to be packaged, they can go in the manifest.
2016-02-24 21:21:02 +01:00 · 2016-02-24 21:18:48 +01:00 · 2016-02-19 19:39:52 +01:00 · 2016-02-19 19:34:20 +01:00 · 2016-02-19 19:17:49 +01:00 · 2016-02-19 10:37:52 +01:00
22 changed files with 581 additions and 65 deletions
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -0,0 +1,2 @@
+include docs/*
+include tests/yaml-1.2-spec-examples/*
--- a/README.rst
+++ b/README.rst
@@ -64,3 +64,19 @@ Usage

 # Output a parsable format (for syntax checking in editors like Vim, emacs...)
 yamllint -f parsable file.yml
+
+Configuration example
+^^^^^^^^^^^^^^^^^^^^^
+
+.. code:: yaml
+
+ extends: default
+
+ rules:
+   # 80 chars should be enough, but don't fail if a line is longer
+   line-length:
+     max: 80
+     level: warning
+
+   # don't bother me with this rule
+   indentation: disable
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -38,6 +38,5 @@ htmlhelp_basename = 'yamllintdoc'
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'yamllint', u'yamllint Documentation',
-     [u'Adrien Vergé'], 1)
+    ('index', 'yamllint', '', [u'Adrien Vergé'], 1)
 ]
--- a/docs/configuration.rst
+++ b/docs/configuration.rst
@@ -50,7 +50,7 @@ strict on block sequences indentation:
 extends: default

 rules:
-   # 80 should be enough, but don't fail if a line is longer
+   # 80 chars should be enough, but don't fail if a line is longer
   line-length:
     max: 80
     level: warning
--- a/setup.py
+++ b/setup.py
@@ -30,7 +30,7 @@ setup(
    keywords=['yaml', 'lint', 'linter', 'syntax', 'checker'],
    url='https://github.com/adrienverge/yamllint',
    classifiers=[
-        'Development Status :: 4 - Beta',
+        'Development Status :: 5 - Production/Stable',
        'Environment :: Console',
        'Intended Audience :: Developers',
        'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
--- a/tests/rules/test_indentation.py
+++ b/tests/rules/test_indentation.py
@@ -15,6 +15,371 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.

 from tests.common import RuleTestCase
+from yamllint.parser import token_generator
+from yamllint.rules.indentation import check
+
+
+class IndentationStackTestCase(RuleTestCase):
+    # This test suite checks that the "indentation stack" built by the
+    # indentation rule is valid. It is important, since everything else in the
+    # rule relies on this stack.
+
+    maxDiff = None
+
+    def format_stack(self, stack):
+        """Transform the stack at a given moment into a printable string like:
+
+        B_MAP:0 KEY:0 VAL:5
+        """
+        return ' '.join(map(str, stack[1:]))
+
+    def full_stack(self, source):
+        conf = {'spaces': 2, 'indent-sequences': True,
+                'check-multi-line-strings': False}
+        context = {}
+        output = ''
+        for elem in token_generator(source):
+            list(check(conf, elem.curr, elem.prev, elem.next, elem.nextnext,
+                       context))
+
+            token_type = (elem.curr.__class__.__name__
+                          .replace('Token', '')
+                          .replace('Block', 'B').replace('Flow', 'F')
+                          .replace('Sequence', 'Seq')
+                          .replace('Mapping', 'Map'))
+            if token_type in ('StreamStart', 'StreamEnd'):
+                continue
+            output += '%9s %s\n' % (token_type,
+                                    self.format_stack(context['stack']))
+        return output
+
+    def test_simple_mapping(self):
+        self.assertMultiLineEqual(
+            self.full_stack('key: val\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:5\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('     key: val\n'),
+            'BMapStart B_MAP:5\n'
+            '      Key B_MAP:5 KEY:5\n'
+            '   Scalar B_MAP:5 KEY:5\n'
+            '    Value B_MAP:5 KEY:5 VAL:10\n'
+            '   Scalar B_MAP:5\n'
+            '     BEnd \n')
+
+    def test_simple_sequence(self):
+        self.assertMultiLineEqual(
+            self.full_stack('- 1\n'
+                            '- 2\n'
+                            '- 3\n'),
+            'BSeqStart B_SEQ:0\n'
+            '   BEntry B_SEQ:0 B_ENT:2\n'
+            '   Scalar B_SEQ:0\n'
+            '   BEntry B_SEQ:0 B_ENT:2\n'
+            '   Scalar B_SEQ:0\n'
+            '   BEntry B_SEQ:0 B_ENT:2\n'
+            '   Scalar B_SEQ:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('key:\n'
+                            '  - 1\n'
+                            '  - 2\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            'BSeqStart B_MAP:0 KEY:0 VAL:2 B_SEQ:2\n'
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:2 B_ENT:4\n'
+            '   Scalar B_MAP:0 KEY:0 VAL:2 B_SEQ:2\n'
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:2 B_ENT:4\n'
+            '   Scalar B_MAP:0 KEY:0 VAL:2 B_SEQ:2\n'
+            '     BEnd B_MAP:0\n'
+            '     BEnd \n')
+
+    def test_non_indented_sequences(self):
+        # There seems to be a bug in pyyaml: depending on the indentation, a
+        # sequence does not produce the same tokens. More precisely, the
+        # following YAML:
+        #     usr:
+        #       - lib
+        # produces a BlockSequenceStartToken and a BlockEndToken around the
+        # "lib" sequence, whereas the following:
+        #     usr:
+        #     - lib
+        # does not (both two tokens are omitted).
+        # So, yamllint must create fake 'B_SEQ'. This test makes sure it does.
+
+        self.assertMultiLineEqual(
+            self.full_stack('usr:\n'
+                            '  - lib\n'
+                            'var: cache\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            'BSeqStart B_MAP:0 KEY:0 VAL:2 B_SEQ:2\n'
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:2 B_ENT:4\n'
+            '   Scalar B_MAP:0 KEY:0 VAL:2 B_SEQ:2\n'
+            '     BEnd B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:5\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('usr:\n'
+                            '- lib\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            # missing BSeqStart here
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2\n'
+            '   Scalar B_MAP:0\n'
+            # missing BEnd here
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('usr:\n'
+                            '- lib\n'
+                            'var: cache\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            # missing BSeqStart here
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2\n'
+            '   Scalar B_MAP:0\n'
+            # missing BEnd here
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:5\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('usr:\n'
+                            '- []\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            # missing BSeqStart here
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2\n'
+            'FSeqStart B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 F_SEQ:3\n'
+            '  FSeqEnd B_MAP:0\n'
+            # missing BEnd here
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('usr:\n'
+                            '- k:\n'
+                            '    v\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            # missing BSeqStart here
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2\n'
+            'BMapStart B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_MAP:2\n'
+            '      Key B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_MAP:2 KEY:2\n'
+            '   Scalar B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_MAP:2 KEY:2\n'
+            '    Value B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_MAP:2 KEY:2 VAL:4\n'  # noqa
+            '   Scalar B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_MAP:2\n'
+            '     BEnd B_MAP:0\n'
+            # missing BEnd here
+            '     BEnd \n')
+
+    def test_flows(self):
+        self.assertMultiLineEqual(
+            self.full_stack('usr: [\n'
+                            '  {k:\n'
+                            '    v}\n'
+                            '  ]\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:5\n'
+            'FSeqStart B_MAP:0 KEY:0 VAL:5 F_SEQ:2\n'
+            'FMapStart B_MAP:0 KEY:0 VAL:5 F_SEQ:2 F_MAP:3\n'
+            '      Key B_MAP:0 KEY:0 VAL:5 F_SEQ:2 F_MAP:3 KEY:3\n'
+            '   Scalar B_MAP:0 KEY:0 VAL:5 F_SEQ:2 F_MAP:3 KEY:3\n'
+            '    Value B_MAP:0 KEY:0 VAL:5 F_SEQ:2 F_MAP:3 KEY:3 VAL:5\n'
+            '   Scalar B_MAP:0 KEY:0 VAL:5 F_SEQ:2 F_MAP:3\n'
+            '  FMapEnd B_MAP:0 KEY:0 VAL:5 F_SEQ:2\n'
+            '  FSeqEnd B_MAP:0\n'
+            '     BEnd \n')
+
+    def test_anchors(self):
+        self.assertMultiLineEqual(
+            self.full_stack('key: &anchor value\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:5\n'
+            '   Anchor B_MAP:0 KEY:0 VAL:5\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('key: &anchor\n'
+                            '  value\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            '   Anchor B_MAP:0 KEY:0 VAL:2\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('- &anchor value\n'),
+            'BSeqStart B_SEQ:0\n'
+            '   BEntry B_SEQ:0 B_ENT:2\n'
+            '   Anchor B_SEQ:0 B_ENT:2\n'
+            '   Scalar B_SEQ:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('- &anchor\n'
+                            '  value\n'),
+            'BSeqStart B_SEQ:0\n'
+            '   BEntry B_SEQ:0 B_ENT:2\n'
+            '   Anchor B_SEQ:0 B_ENT:2\n'
+            '   Scalar B_SEQ:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('- &anchor\n'
+                            '  - 1\n'
+                            '  - 2\n'),
+            'BSeqStart B_SEQ:0\n'
+            '   BEntry B_SEQ:0 B_ENT:2\n'
+            '   Anchor B_SEQ:0 B_ENT:2\n'
+            'BSeqStart B_SEQ:0 B_ENT:2 B_SEQ:2\n'
+            '   BEntry B_SEQ:0 B_ENT:2 B_SEQ:2 B_ENT:4\n'
+            '   Scalar B_SEQ:0 B_ENT:2 B_SEQ:2\n'
+            '   BEntry B_SEQ:0 B_ENT:2 B_SEQ:2 B_ENT:4\n'
+            '   Scalar B_SEQ:0 B_ENT:2 B_SEQ:2\n'
+            '     BEnd B_SEQ:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('&anchor key:\n'
+                            '  value\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Anchor B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('pre:\n'
+                            '  &anchor1 0\n'
+                            '&anchor2 key:\n'
+                            '  value\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            '   Anchor B_MAP:0 KEY:0 VAL:2\n'
+            '   Scalar B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Anchor B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('sequence: &anchor\n'
+                            '- entry\n'
+                            '- &anchor\n'
+                            '  - nested\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            '   Anchor B_MAP:0 KEY:0 VAL:2\n'
+            # missing BSeqStart here
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2\n'
+            '   Scalar B_MAP:0 KEY:0 VAL:2 B_SEQ:0\n'
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2\n'
+            '   Anchor B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2\n'
+            'BSeqStart B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_SEQ:2\n'
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_SEQ:2 B_ENT:4\n'
+            '   Scalar B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_SEQ:2\n'
+            '     BEnd B_MAP:0\n'
+            # missing BEnd here
+            '     BEnd \n')
+
+    def test_tags(self):
+        self.assertMultiLineEqual(
+            self.full_stack('key: !!tag value\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:5\n'
+            '      Tag B_MAP:0 KEY:0 VAL:5\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('- !!map # Block collection\n'
+                            '  foo : bar\n'),
+            'BSeqStart B_SEQ:0\n'
+            '   BEntry B_SEQ:0 B_ENT:2\n'
+            '      Tag B_SEQ:0 B_ENT:2\n'
+            'BMapStart B_SEQ:0 B_ENT:2 B_MAP:2\n'
+            '      Key B_SEQ:0 B_ENT:2 B_MAP:2 KEY:2\n'
+            '   Scalar B_SEQ:0 B_ENT:2 B_MAP:2 KEY:2\n'
+            '    Value B_SEQ:0 B_ENT:2 B_MAP:2 KEY:2 VAL:8\n'
+            '   Scalar B_SEQ:0 B_ENT:2 B_MAP:2\n'
+            '     BEnd B_SEQ:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('- !!seq\n'
+                            '  - nested item\n'),
+            'BSeqStart B_SEQ:0\n'
+            '   BEntry B_SEQ:0 B_ENT:2\n'
+            '      Tag B_SEQ:0 B_ENT:2\n'
+            'BSeqStart B_SEQ:0 B_ENT:2 B_SEQ:2\n'
+            '   BEntry B_SEQ:0 B_ENT:2 B_SEQ:2 B_ENT:4\n'
+            '   Scalar B_SEQ:0 B_ENT:2 B_SEQ:2\n'
+            '     BEnd B_SEQ:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('sequence: !!seq\n'
+                            '- entry\n'
+                            '- !!seq\n'
+                            '  - nested\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            '   Scalar B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:2\n'
+            '      Tag B_MAP:0 KEY:0 VAL:2\n'
+            # missing BSeqStart here
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2\n'
+            '   Scalar B_MAP:0 KEY:0 VAL:2 B_SEQ:0\n'
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2\n'
+            '      Tag B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2\n'
+            'BSeqStart B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_SEQ:2\n'
+            '   BEntry B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_SEQ:2 B_ENT:4\n'
+            '   Scalar B_MAP:0 KEY:0 VAL:2 B_SEQ:0 B_ENT:2 B_SEQ:2\n'
+            '     BEnd B_MAP:0\n'
+            # missing BEnd here
+            '     BEnd \n')


 class IndentationTestCase(RuleTestCase):
@@ -670,6 +1035,95 @@ class IndentationTestCase(RuleTestCase):
                   '      line\n'
                   '...\n', conf, problem=(4, 6))

+    def test_anchors(self):
+        conf = 'indentation: {spaces: 2}'
+        self.check('---\n'
+                   'key: &anchor value\n', conf)
+        self.check('---\n'
+                   'key: &anchor\n'
+                   '  value\n', conf)
+        self.check('---\n'
+                   '- &anchor value\n', conf)
+        self.check('---\n'
+                   '- &anchor\n'
+                   '  value\n', conf)
+        self.check('---\n'
+                   'key: &anchor [1,\n'
+                   '              2]\n', conf)
+        self.check('---\n'
+                   'key: &anchor\n'
+                   '  [1,\n'
+                   '   2]\n', conf)
+        self.check('---\n'
+                   'key: &anchor\n'
+                   '  - 1\n'
+                   '  - 2\n', conf)
+        self.check('---\n'
+                   '- &anchor [1,\n'
+                   '           2]\n', conf)
+        self.check('---\n'
+                   '- &anchor\n'
+                   '  [1,\n'
+                   '   2]\n', conf)
+        self.check('---\n'
+                   '- &anchor\n'
+                   '  - 1\n'
+                   '  - 2\n', conf)
+        self.check('---\n'
+                   'key:\n'
+                   '  &anchor1\n'
+                   '  value\n', conf)
+        self.check('---\n'
+                   'pre:\n'
+                   '  &anchor1 0\n'
+                   '&anchor2 key:\n'
+                   '  value\n', conf)
+        self.check('---\n'
+                   'machine0:\n'
+                   '  /etc/hosts: &ref-etc-hosts\n'
+                   '    content:\n'
+                   '      - 127.0.0.1: localhost\n'
+                   '      - ::1: localhost\n'
+                   '    mode: 0644\n'
+                   'machine1:\n'
+                   '  /etc/hosts: *ref-etc-hosts\n', conf)
+        self.check('---\n'
+                   'list:\n'
+                   '  - k: v\n'
+                   '  - &a truc\n'
+                   '  - &b\n'
+                   '    truc\n'
+                   '  - k: *a\n', conf)
+
+    def test_tags(self):
+        conf = 'indentation: {spaces: 2}'
+        self.check('---\n'
+                   '-\n'
+                   '  "flow in block"\n'
+                   '- >\n'
+                   '    Block scalar\n'
+                   '- !!map  # Block collection\n'
+                   '  foo: bar\n', conf)
+
+        conf = 'indentation: {spaces: 2, indent-sequences: no}'
+        self.check('---\n'
+                   'sequence: !!seq\n'
+                   '- entry\n'
+                   '- !!seq\n'
+                   '  - nested\n', conf)
+        self.check('---\n'
+                   'mapping: !!map\n'
+                   '  foo: bar\n'
+                   'Block style: !!map\n'
+                   '  Clark: Evans\n'
+                   '  Ingy: döt Net\n'
+                   '  Oren: Ben-Kiki\n', conf)
+        self.check('---\n'
+                   'Flow style: !!map {Clark: Evans, Ingy: döt Net}\n'
+                   'Block style: !!seq\n'
+                   '- Clark Evans\n'
+                   '- Ingy döt Net\n', conf)
+

 class ScalarIndentationTestCase(RuleTestCase):
    rule_id = 'indentation'
--- a/tests/test_spec_examples.py
+++ b/tests/test_spec_examples.py
@@ -96,6 +96,7 @@ conf_overrides = {
    'example-7.15': ('braces: {min-spaces-inside: 0, max-spaces-inside: 1}\n'
                     'commas: {max-spaces-before: 1, min-spaces-after: 0}\n'
                     'colons: {max-spaces-before: 1}\n'),
+    'example-7.16': ('indentation: disable\n'),
    'example-7.17': ('indentation: disable\n'),
    'example-7.18': ('indentation: disable\n'),
    'example-7.19': ('indentation: disable\n'),
@@ -112,6 +113,11 @@ conf_overrides = {
    'example-8.14': ('colons: {max-spaces-before: 1}\n'),
    'example-8.16': ('indentation: {spaces: 1}\n'),
    'example-8.17': ('indentation: disable\n'),
+    'example-8.20': ('indentation: {indent-sequences: no}\n'
+                     'colons: {max-spaces-before: 1}\n'),
+    'example-8.22': ('indentation: disable\n'),
+    'example-10.1': ('colons: {max-spaces-before: 2}\n'),
+    'example-10.2': ('indentation: {indent-sequences: no}\n'),
 }

 files = os.listdir('tests/yaml-1.2-spec-examples')
@@ -123,15 +129,6 @@ def _gen_test(buffer, conf):
        self.check(buffer, conf)
    return test

-# TODO
-# The following tests are blacklisted because they contain rarely-used formats
-# that yamllint does not handle yet.
-tmp_blacklist = (
-    'example-7.16',
-    'example-8.20',
-    'example-8.22',
-    'example-10.1',
-)
 # The following tests are blacklisted (i.e. will not be checked against
 # yamllint), because pyyaml is currently not able to parse the contents
 # (using yaml.parse()).
@@ -178,7 +175,7 @@ pyyaml_blacklist = (
 )

 for file in files:
-    if file in tmp_blacklist or file in pyyaml_blacklist:
+    if file in pyyaml_blacklist:
        continue

    with open('tests/yaml-1.2-spec-examples/' + file) as f:
--- a/yamllint/init.py
+++ b/yamllint/init.py
@@ -22,7 +22,7 @@ indentation, etc."""


 APP_NAME = 'yamllint'
-APP_VERSION = '0.7.1'
+APP_VERSION = '1.0.2'
 APP_DESCRIPTION = __doc__

 __author__ = u'Adrien Vergé'
--- a/yamllint/cli.py
+++ b/yamllint/cli.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
--- a/yamllint/linter.py
+++ b/yamllint/linter.py
@@ -68,6 +68,7 @@ def get_costemic_problems(buffer, conf):
                rule_conf = conf.rules[rule.ID]
                for problem in rule.check(rule_conf,
                                          elem.curr, elem.prev, elem.next,
+                                          elem.nextnext,
                                          context[rule.ID]):
                    problem.rule = rule.ID
                    problem.level = rule_conf['level']
--- a/yamllint/parser.py
+++ b/yamllint/parser.py
@@ -30,11 +30,12 @@ class Line(object):


 class Token(object):
-    def __init__(self, line_no, curr, prev, next):
+    def __init__(self, line_no, curr, prev, next, nextnext):
        self.line_no = line_no
        self.curr = curr
        self.prev = prev
        self.next = next
+        self.nextnext = nextnext


 def line_generator(buffer):
@@ -55,14 +56,16 @@ def token_generator(buffer):

    try:
        prev = None
-        next = yaml_loader.peek_token()
-        while next is not None:
-            curr = yaml_loader.get_token()
-            next = yaml_loader.peek_token()
+        curr = yaml_loader.get_token()
+        while curr is not None:
+            next = yaml_loader.get_token()
+            nextnext = yaml_loader.peek_token()

-            yield Token(curr.start_mark.line + 1, curr, prev, next)
+            yield Token(curr.start_mark.line + 1, curr, prev, next, nextnext)

            prev = curr
+            curr = next
+
    except yaml.scanner.ScannerError:
        pass

--- a/yamllint/rules/braces.py
+++ b/yamllint/rules/braces.py
@@ -73,7 +73,7 @@ CONF = {'min-spaces-inside': int,
        'max-spaces-inside': int}


-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    if isinstance(token, yaml.FlowMappingStartToken):
        problem = spaces_after(token, prev, next,
                               min=conf['min-spaces-inside'],
--- a/yamllint/rules/brackets.py
+++ b/yamllint/rules/brackets.py
@@ -74,7 +74,7 @@ CONF = {'min-spaces-inside': int,
        'max-spaces-inside': int}


-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    if isinstance(token, yaml.FlowSequenceStartToken):
        problem = spaces_after(token, prev, next,
                               min=conf['min-spaces-inside'],
--- a/yamllint/rules/colons.py
+++ b/yamllint/rules/colons.py
@@ -81,7 +81,7 @@ CONF = {'max-spaces-before': int,
        'max-spaces-after': int}


-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    if isinstance(token, yaml.ValueToken):
        problem = spaces_before(token, prev, next,
                                max=conf['max-spaces-before'],
--- a/yamllint/rules/commas.py
+++ b/yamllint/rules/commas.py
@@ -105,7 +105,7 @@ CONF = {'max-spaces-before': int,
        'max-spaces-after': int}


-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    if isinstance(token, yaml.FlowEntryToken):
        if (prev is not None and conf['max-spaces-before'] != -1 and
                prev.end_mark.line < token.start_mark.line):
--- a/yamllint/rules/comments.py
+++ b/yamllint/rules/comments.py
@@ -67,7 +67,7 @@ CONF = {'require-starting-space': bool,
        'min-spaces-from-content': int}


-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    for comment in get_comments_between_tokens(token, next):
        if (conf['min-spaces-from-content'] != -1 and
                not isinstance(token, yaml.StreamStartToken) and
--- a/yamllint/rules/comments_indentation.py
+++ b/yamllint/rules/comments_indentation.py
@@ -98,7 +98,7 @@ TYPE = 'token'
 #     # commented line 2
 #     current: line

-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    if prev is None:
        return

--- a/yamllint/rules/document_end.py
+++ b/yamllint/rules/document_end.py
@@ -84,7 +84,7 @@ TYPE = 'token'
 CONF = {'present': bool}


-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    if conf['present']:
        if (isinstance(token, yaml.StreamEndToken) and
                not (isinstance(prev, yaml.DocumentEndToken) or
--- a/yamllint/rules/document_start.py
+++ b/yamllint/rules/document_start.py
@@ -74,7 +74,7 @@ TYPE = 'token'
 CONF = {'present': bool}


-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    if conf['present']:
        if (isinstance(prev, (yaml.StreamStartToken,
                              yaml.DocumentEndToken,
--- a/yamllint/rules/hyphens.py
+++ b/yamllint/rules/hyphens.py
@@ -78,7 +78,7 @@ TYPE = 'token'
 CONF = {'max-spaces-after': int}


-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    if isinstance(token, yaml.BlockEntryToken):
        problem = spaces_after(token, prev, next,
                               max=conf['max-spaces-after'],
--- a/yamllint/rules/indentation.py
+++ b/yamllint/rules/indentation.py
@@ -154,7 +154,8 @@ CONF = {'spaces': int,
        'indent-sequences': (True, False, 'whatever'),
        'check-multi-line-strings': bool}

-ROOT, MAP, B_SEQ, F_SEQ, B_ENT, KEY, VAL = range(7)
+ROOT, B_MAP, F_MAP, B_SEQ, F_SEQ, B_ENT, KEY, VAL = range(8)
+labels = ('ROOT', 'B_MAP', 'F_MAP', 'B_SEQ', 'F_SEQ', 'B_ENT', 'KEY', 'VAL')


 class Parent(object):
@@ -163,6 +164,10 @@ class Parent(object):
        self.indent = indent
        self.line_indent = line_indent
        self.explicit_key = False
+        self.implicit_block_seq = False
+
+    def __repr__(self):
+        return '%s:%d' % (labels[self.type], self.indent)


 def check_scalar_indentation(conf, token, context):
@@ -231,7 +236,7 @@ def check_scalar_indentation(conf, token, context):
                              (expected_indent, indent))


-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    if 'stack' not in context:
        context['stack'] = [Parent(ROOT, 0)]
        context['cur_line'] = -1
@@ -276,9 +281,6 @@ def check(conf, token, prev, next, context):

    # Step 2.b: Update state

-    if context['stack'][-1].type == B_ENT:
-        context['stack'].pop()
-
    if isinstance(token, yaml.BlockMappingStartToken):
        assert isinstance(next, yaml.KeyToken)
        if next.start_mark.line == token.start_mark.line:
@@ -294,7 +296,7 @@ def check(conf, token, prev, next, context):
            #     : 1
            indent = token.start_mark.column + conf['spaces']

-        context['stack'].append(Parent(MAP, indent))
+        context['stack'].append(Parent(B_MAP, indent))

    elif isinstance(token, yaml.FlowMappingStartToken):
        if next.start_mark.line == token.start_mark.line:
@@ -306,7 +308,7 @@ def check(conf, token, prev, next, context):
            #   }
            indent = context['cur_line_indent'] + conf['spaces']

-        context['stack'].append(Parent(MAP, indent,
+        context['stack'].append(Parent(F_MAP, indent,
                                       line_indent=context['cur_line_indent']))

    elif isinstance(token, yaml.BlockSequenceStartToken):
@@ -322,6 +324,12 @@ def check(conf, token, prev, next, context):
    elif (isinstance(token, yaml.BlockEntryToken) and
            # in case of an empty entry
            not isinstance(next, (yaml.BlockEntryToken, yaml.BlockEndToken))):
+        # It looks like pyyaml doesn't issue BlockSequenceStartTokens when the
+        # list is not indented. We need to compensate that.
+        if context['stack'][-1].type != B_SEQ:
+            context['stack'].append(Parent(B_SEQ, token.start_mark.column))
+            context['stack'][-1].implicit_block_seq = True
+
        if next.start_mark.line == token.end_mark.line:
            #   - item 1
            #   - item 2
@@ -349,12 +357,6 @@ def check(conf, token, prev, next, context):
        context['stack'].append(Parent(F_SEQ, indent,
                                       line_indent=context['cur_line_indent']))

-    elif isinstance(token, (yaml.BlockEndToken,
-                            yaml.FlowMappingEndToken,
-                            yaml.FlowSequenceEndToken)):
-        assert context['stack'][-1].type in (MAP, B_SEQ, F_SEQ)
-        context['stack'].pop()
-
    elif isinstance(token, yaml.KeyToken):
        indent = context['stack'][-1].indent

@@ -362,21 +364,25 @@ def check(conf, token, prev, next, context):

        context['stack'][-1].explicit_key = is_explicit_key(token)

-    if context['stack'][-1].type == VAL:
-        context['stack'].pop()
-        assert context['stack'][-1].type == KEY
-        context['stack'].pop()
-
    elif isinstance(token, yaml.ValueToken):
        assert context['stack'][-1].type == KEY

-        # Discard empty values
-        if isinstance(next, (yaml.BlockEndToken,
-                             yaml.FlowMappingEndToken,
-                             yaml.FlowSequenceEndToken,
-                             yaml.KeyToken)):
-            context['stack'].pop()
-        else:
+        # Special cases:
+        #     key: &anchor
+        #       value
+        # and:
+        #     key: !!tag
+        #       value
+        if isinstance(next, (yaml.AnchorToken, yaml.TagToken)):
+            if (next.start_mark.line == prev.start_mark.line and
+                    next.start_mark.line < nextnext.start_mark.line):
+                next = nextnext
+
+        # Only if value is not empty
+        if not isinstance(next, (yaml.BlockEndToken,
+                                 yaml.FlowMappingEndToken,
+                                 yaml.FlowSequenceEndToken,
+                                 yaml.KeyToken)):
            if context['stack'][-1].explicit_key:
                #   ? k
                #   : value
@@ -417,11 +423,50 @@ def check(conf, token, prev, next, context):

            context['stack'].append(Parent(VAL, indent))

-    if (context['stack'][-1].type == KEY and
-            isinstance(next, (yaml.BlockEndToken,
-                              yaml.FlowMappingEndToken,
-                              yaml.FlowSequenceEndToken,
-                              yaml.KeyToken))):
-        # A key without a value: it's part of a set. Let's drop this key
-        # and leave room for the next one.
-        context['stack'].pop()
+    consumed_current_token = False
+    while True:
+        if (context['stack'][-1].type == F_SEQ and
+                isinstance(token, yaml.FlowSequenceEndToken)):
+            context['stack'].pop()
+
+        elif (context['stack'][-1].type == F_MAP and
+                isinstance(token, yaml.FlowMappingEndToken)):
+            context['stack'].pop()
+
+        elif (context['stack'][-1].type in (B_MAP, B_SEQ) and
+                isinstance(token, yaml.BlockEndToken) and
+                not context['stack'][-1].implicit_block_seq and
+                not consumed_current_token):
+            context['stack'].pop()
+            consumed_current_token = True
+
+        elif (context['stack'][-1].type == B_ENT and
+                not isinstance(token, yaml.BlockEntryToken) and
+                context['stack'][-2].implicit_block_seq and
+                not isinstance(token, (yaml.AnchorToken, yaml.TagToken)) and
+                not isinstance(next, yaml.BlockEntryToken)):
+            context['stack'].pop()
+            context['stack'].pop()
+
+        elif (context['stack'][-1].type == B_ENT and
+                isinstance(next, (yaml.BlockEntryToken, yaml.BlockEndToken))):
+            context['stack'].pop()
+
+        elif (context['stack'][-1].type == VAL and
+                not isinstance(token, yaml.ValueToken) and
+                not isinstance(token, (yaml.AnchorToken, yaml.TagToken))):
+            assert context['stack'][-2].type == KEY
+            context['stack'].pop()
+            context['stack'].pop()
+
+        elif (context['stack'][-1].type == KEY and
+                isinstance(next, (yaml.BlockEndToken,
+                                  yaml.FlowMappingEndToken,
+                                  yaml.FlowSequenceEndToken,
+                                  yaml.KeyToken))):
+            # A key without a value: it's part of a set. Let's drop this key
+            # and leave room for the next one.
+            context['stack'].pop()
+
+        else:
+            break
--- a/yamllint/rules/key_duplicates.py
+++ b/yamllint/rules/key_duplicates.py
@@ -72,7 +72,7 @@ class Parent(object):
        self.keys = []


-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
    if 'stack' not in context:
        context['stack'] = []
Author	SHA1	Message	Date
Adrien Vergé	ca0ebe4583	yamllint version 1.0.2	2016-02-24 21:21:02 +01:00
Adrien Vergé	e6dc67fd0a	Distribution: Add MANIFEST.in `yamllint/conf/.yml` remains in `setup.py`'s `package_data` because it needs to be installed when running `pip install .`. `docs/` and `tests/yaml-1.2-spec-examples/*` just need to be packaged, they can go in the manifest.	2016-02-24 21:18:48 +01:00
Adrien Vergé	611a560082	yamllint version 1.0.1	2016-02-19 19:39:52 +01:00
Adrien Vergé	83384fa4cf	Doc: Fix man page redundant description	2016-02-19 19:34:20 +01:00
Adrien Vergé	3ab3784a75	cli: Remove shebang A shebang is present at the beginning of file, it dates from the time when `yamllint/cli.py` was `bin/yamllint`, i.e. an executable launcher. Since this is not the case anymore (see `entry_points` section in `setup.py`), let's remove it.	2016-02-19 19:17:49 +01:00
Adrien Vergé	2f75e92a66	Doc: Add a configuration example in README	2016-02-19 10:37:52 +01:00
Adrien Vergé	64caa95b6a	yamllint version 1.0.0	2016-02-19 10:15:23 +01:00
Adrien Vergé	fff09fa2df	Distribution: Ship example files from spec in sdist Closes: #1	2016-02-19 10:14:59 +01:00
Adrien Vergé	316bee8c98	yamllint version 0.7.2	2016-02-05 11:28:15 +01:00
Adrien Vergé	6c8af97a40	Tests: unblacklist remaining spec examples Since !!tags are now supported.	2016-02-05 11:14:37 +01:00
Adrien Vergé	647d84ff94	Rules: indentation: Handle tags	2016-02-05 11:13:44 +01:00
Adrien Vergé	8eb0d0ad74	Tests: unblacklist spec example 7.16 As is it supported -- it just lacks some indentation.	2016-02-05 09:52:09 +01:00
Adrien Vergé	4bc3d5a01c	Rules: indentation: Handle anchors	2016-02-04 22:10:40 +01:00
Adrien Vergé	48c7d65c54	parser: Provide nextnext for token rules Because the indentation rule sometimes needs to look two tokens forward (in case of anchors for instance).	2016-02-04 22:10:40 +01:00
Adrien Vergé	62fa4cbe39	Tests: indentation: Test the indent stack The "indentation stack" is iteratively built by the `check()` function of the indentation rule. It is important, since everything in the rule relies on it. This patch adds tests to make sure the stack is correctly built for some known structures.	2016-02-04 22:10:40 +01:00
Adrien Vergé	8d38d349ac	Rules: indentation: Rewrite stack generation "Indentation stack" generation was not done properly, hence did not work in all cases. This commit does a cleaner rewriting.	2016-02-04 21:47:08 +01:00