yamllint version 1.3.0

There is *always* a `Line` element at the end of file, even if the
newline character (`\n`) is missing.

.gitignore

@@ -1,3 +1,5 @@
 __pycache__
 *.py[cod]
 /docs/_build
+/dist
+/yamllint.egg-info

.travis.yml

@@ -11,7 +11,7 @@ install:
   - pip install .
 script:
   - flake8 .
-  - yamllint $(git ls-files '*.yml')
+  - yamllint $(git ls-files '*.yaml' '*.yml')
   - coverage run --source=yamllint setup.py test
 after_success:
   coveralls

README.rst

@@ -24,10 +24,10 @@ Written in Python (compatible with Python 2 & 3).
 Documentation
 -------------
 
-http://yamllint.readthedocs.org/
+http://yamllint.readthedocs.io/
 
-Short overview
---------------
+Overview
+--------
 
 Screenshot
 ^^^^^^^^^^
@@ -38,6 +38,20 @@ Screenshot
 Installation
 ^^^^^^^^^^^^
 
+On Fedora / CentOS:
+
+.. code:: bash
+
+ sudo dnf install yamllint
+
+On Debian 9+ / Ubuntu 16.04+:
+
+.. code:: bash
+
+ sudo apt-get install yamllint
+
+Alternatively using pip, the Python package manager:
+
 .. code:: bash
 
  sudo pip install yamllint
@@ -58,18 +72,22 @@ Usage
 .. code:: bash
 
  # Use a pre-defined lint configuration
- yamllint -d relaxed file.yml
+ yamllint -d relaxed file.yaml
 
  # Use a custom lint configuration
- yamllint -c ~/myconfig file.yml
+ yamllint -c /path/to/myconfig file-to-lint.yaml
 
 .. code:: bash
 
  # Output a parsable format (for syntax checking in editors like Vim, emacs...)
- yamllint -f parsable file.yml
+ yamllint -f parsable file.yaml
 
-Configuration example
-^^^^^^^^^^^^^^^^^^^^^
+`Read more in the complete documentation! <http://yamllint.readthedocs.io/>`_
+
+Features
+^^^^^^^^
+
+Here is a yamllint configuration file example:
 
 .. code:: yaml
 
@@ -83,3 +101,27 @@ Configuration example
 
    # don't bother me with this rule
    indentation: disable
+
+Within a YAML file, special comments can be used to disable checks for a single
+line:
+
+.. code:: yaml
+
+ This line is waaaaaaaaaay too long  # yamllint disable-line
+
+or for a whole block:
+
+.. code:: yaml
+
+ # yamllint disable rule:colons
+ - Lorem       : ipsum
+   dolor       : sit amet,
+   consectetur : adipiscing elit
+ # yamllint enable
+
+`Read more in the complete documentation! <http://yamllint.readthedocs.io/>`_
+
+License
+-------
+
+`GPL version 3 <LICENSE>`_

docs/configuration.rst

@@ -1,23 +1,31 @@
 Configuration
 =============
 
-yamllint uses a set of *rules* to check sources files for problems. Each rule is
-independent from the others, and can be enabled, disabled or tweaked. All these
-settings can be gathered in a configuration file.
+yamllint uses a set of :doc:`rules <rules>` to check source files for problems.
+Each rule is independent from the others, and can be enabled, disabled or
+tweaked. All these settings can be gathered in a configuration file.
 
-To use a custom configuration file, either name it ``.yamllint`` in your working
-directory, or use the ``-c`` option:
+To use a custom configuration file, use the ``-c`` option:
 
 .. code:: bash
 
- yamllint -c ~/myconfig file.yml
+ yamllint -c /path/to/myconfig file-to-lint.yaml
+
+If ``-c`` is not provided, yamllint will look for a configuration file in the
+following locations (by order of preference):
+
+- ``.yamllint`` in the current working directory
+- ``$XDG_CONFIG_HOME/yamllint/config``
+- ``~/.config/yamllint/config``
+
+Finally if no config file is found, the default configuration is applied.
 
 Default configuration
 ---------------------
 
 Unless told otherwise, yamllint uses its ``default`` configuration:
 
-.. literalinclude:: ../yamllint/conf/default.yml
+.. literalinclude:: ../yamllint/conf/default.yaml
    :language: yaml
 
 Details on rules can be found on :doc:`the rules page <rules>`.
@@ -85,7 +93,7 @@ For instance:
 
 .. code:: bash
 
- yamllint -d "{extends: relaxed, rules: {line-length: {max: 120}}}" file.yml
+ yamllint -d "{extends: relaxed, rules: {line-length: {max: 120}}}" file.yaml
 
 Errors and warnings
 -------------------

docs/disable_with_comments.rst

@@ -0,0 +1,75 @@
+Disable with comments
+=====================
+
+Disabling checks for a specific line
+------------------------------------
+
+To prevent yamllint from reporting problems for a specific line, add a directive
+comment (``# yamllint disable-line ...``) on that line, or on the line above.
+For instance:
+
+.. code-block:: yaml
+
+ # The following mapping contains the same key twice,
+ # but I know what I'm doing:
+ key: value 1
+ key: value 2  # yamllint disable-line rule:key-duplicates
+
+ - This line is waaaaaaaaaay too long but yamllint will not report anything about it.  # yamllint disable-line rule:line-length
+   This line will be checked by yamllint.
+
+or:
+
+.. code-block:: yaml
+
+ # The following mapping contains the same key twice,
+ # but I know what I'm doing:
+ key: value 1
+ # yamllint disable-line rule:key-duplicates
+ key: value 2
+
+ # yamllint disable-line rule:line-length
+ - This line is waaaaaaaaaay too long but yamllint will not report anything about it.
+   This line will be checked by yamllint.
+
+It it possible, although not recommend, to disabled **all** rules for a
+specific line:
+
+.. code-block:: yaml
+
+ # yamllint disable-line
+ -  {    all : rules ,are disabled   for this line}
+
+If you need to disable multiple rules, it is allowed to chain rules like this:
+``# yamllint disable-line rule:hyphens rule:commas rule:indentation``.
+
+Disabling checks for all (or part of) the file
+----------------------------------------------
+
+To prevent yamllint from reporting problems for the whoe file, or for a block of
+lines within the file, use ``# yamllint disable ...`` and ``# yamllint enable
+...`` directive comments. For instance:
+
+.. code-block:: yaml
+
+ # yamllint disable rule:colons
+ - Lorem       : ipsum
+   dolor       : sit amet,
+   consectetur : adipiscing elit
+ # yamllint enable rule:colons
+
+ - rest of the document...
+
+It it possible, although not recommend, to disabled **all** rules:
+
+.. code-block:: yaml
+
+ # yamllint disable
+ - Lorem       :
+         ipsum:
+           dolor : [   sit,amet]
+ -         consectetur : adipiscing elit
+ # yamllint enable
+
+If you need to disable multiple rules, it is allowed to chain rules like this:
+``# yamllint disable rule:hyphens rule:commas rule:indentation``.

docs/index.rst

@@ -23,5 +23,6 @@ Table of contents
    quickstart
    configuration
    rules
+   disable_with_comments
    development
    text_editors

docs/quickstart.rst

@@ -4,16 +4,34 @@ Quickstart
 Installing yamllint
 -------------------
 
-First, install yamllint. The easiest way is to use pip, the Python package
-manager:
+On Fedora / CentOS:
 
-::
+.. code:: bash
+
+ sudo dnf install yamllint
+
+On Debian 9+ / Ubuntu 16.04+:
+
+.. code:: bash
+
+ sudo apt-get install yamllint
+
+On older Debian / Ubuntu versions:
+
+.. code:: bash
+
+ sudo add-apt-repository -y ppa:adrienverge/ppa && sudo apt-get update
+ sudo apt-get install yamllint
+
+Alternatively using pip, the Python package manager:
+
+.. code:: bash
 
  sudo pip install yamllint
 
 If you prefer installing from source, you can run, from the source directory:
 
-::
+.. code:: bash
 
  python setup.py sdist
  sudo pip install dist/yamllint-*.tar.gz
@@ -23,13 +41,13 @@ Running yamllint
 
 Basic usage:
 
-::
+.. code:: bash
 
  yamllint file.yml other-file.yaml
 
 You can also lint all YAML files in a whole directory:
 
-::
+.. code:: bash
 
  yamllint .
 
@@ -65,9 +83,9 @@ If you have a custom linting configuration file (see :doc:`how to configure
 yamllint <configuration>`), it can be passed to yamllint using the ``-c``
 option:
 
-::
+.. code:: bash
 
- yamllint -c ~/myconfig file.yml
+ yamllint -c ~/myconfig file.yaml
 
 .. note::
 

docs/text_editors.rst

@@ -20,16 +20,8 @@ Neovim
 ------
 
 Assuming that the `neomake <https://github.com/benekastah/neomake>`_ plugin is
-installed, add to your ``.config/nvim/init.vim``:
-
-::
-
- if executable('yamllint')
-   let g:neomake_yaml_yamllint_maker = {
-     \ 'args': ['-f', 'parsable'],
-     \ 'errorformat': '%E%f:%l:%c: [error] %m,%W%f:%l:%c: [warning] %m' }
-   let g:neomake_yaml_enabled_makers = ['yamllint']
- endif
+installed, yamllint is supported by default. It is automatically enabled when
+editing YAML files.
 
 Other text editors
 ------------------

setup.py

@@ -44,7 +44,7 @@ setup(
 
     packages=find_packages(),
     entry_points={'console_scripts': ['yamllint=yamllint.cli:run']},
-    package_data={'yamllint': ['conf/*.yml'],
+    package_data={'yamllint': ['conf/*.yaml'],
                   'tests': ['yaml-1.2-spec-examples/*']},
     install_requires=['pyyaml'],
     tests_require=['nose'],

tests/rules/test_comments_indentation.py

@@ -49,7 +49,7 @@ class CommentsIndentationTestCase(RuleTestCase):
                    '...\n', conf)
 
     def test_enabled(self):
-        conf = 'comments-indentation: {}'
+        conf = 'comments-indentation: enable'
         self.check('---\n'
                    '# line 1\n'
                    '# line 2\n', conf)
@@ -58,7 +58,7 @@ class CommentsIndentationTestCase(RuleTestCase):
                    '# line 2\n', conf, problem=(2, 2))
         self.check('---\n'
                    '  # line 1\n'
-                   '  # line 2\n', conf, problem1=(2, 3), problem2=(3, 3))
+                   '  # line 2\n', conf, problem1=(2, 3))
         self.check('---\n'
                    'obj:\n'
                    '  # normal\n'
@@ -123,18 +123,18 @@ class CommentsIndentationTestCase(RuleTestCase):
                    '...\n', conf)
 
     def test_first_line(self):
-        conf = 'comments-indentation: {}'
+        conf = 'comments-indentation: enable'
         self.check('# comment\n', conf)
         self.check('  # comment\n', conf, problem=(1, 3))
 
     def test_no_newline_at_end(self):
-        conf = ('comments-indentation: {}\n'
+        conf = ('comments-indentation: enable\n'
                 'new-line-at-end-of-file: disable\n')
         self.check('# comment', conf)
         self.check('  # comment', conf, problem=(1, 3))
 
     def test_empty_comment(self):
-        conf = 'comments-indentation: {}'
+        conf = 'comments-indentation: enable'
         self.check('---\n'
                    '# hey\n'
                    '# normal\n'
@@ -143,3 +143,15 @@ class CommentsIndentationTestCase(RuleTestCase):
                    '# hey\n'
                    '# normal\n'
                    ' #\n', conf, problem=(4, 2))
+
+    def test_inline_comment(self):
+        conf = 'comments-indentation: enable'
+        self.check('---\n'
+                   '- a  # inline\n'
+                   '# ok\n', conf)
+        self.check('---\n'
+                   '- a  # inline\n'
+                   ' # not ok\n', conf, problem=(3, 2))
+        self.check('---\n'
+                   ' # not ok\n'
+                   '- a  # inline\n', conf, problem=(2, 2))

tests/rules/test_common.py

@@ -18,8 +18,7 @@ import unittest
 
 import yaml
 
-from yamllint.rules.common import (Comment, get_line_indent,
-                                   get_comments_between_tokens)
+from yamllint.rules.common import get_line_indent
 
 
 class CommonTestCase(unittest.TestCase):
@@ -43,54 +42,3 @@ class CommonTestCase(unittest.TestCase):
             self.assertEqual(get_line_indent(tokens[i]), 0)
         for i in (13, 16, 18, 22, 24):
             self.assertEqual(get_line_indent(tokens[i]), 2)
-
-    def check_comments(self, buffer, *expected):
-        yaml_loader = yaml.BaseLoader(buffer)
-
-        comments = []
-
-        next = yaml_loader.peek_token()
-        while next is not None:
-            curr = yaml_loader.get_token()
-            next = yaml_loader.peek_token()
-            for comment in get_comments_between_tokens(curr, next):
-                comments.append(comment)
-
-        self.assertEqual(comments, list(expected))
-
-    def test_get_comments_between_tokens(self):
-        self.check_comments('# comment\n',
-                            Comment(1, 1, '# comment', 0))
-        self.check_comments('---\n'
-                            '# comment\n'
-                            '...\n',
-                            Comment(2, 1, '# comment', 0))
-        self.check_comments('---\n'
-                            '# no newline char',
-                            Comment(2, 1, '# no newline char', 0))
-        self.check_comments('# just comment',
-                            Comment(1, 1, '# just comment', 0))
-        self.check_comments('\n'
-                            '   # indented comment\n',
-                            Comment(2, 4, '# indented comment', 0))
-        self.check_comments('\n'
-                            '# trailing spaces    \n',
-                            Comment(2, 1, '# trailing spaces    ', 0))
-        self.check_comments('# comment one\n'
-                            '\n'
-                            'key: val  # key=val\n'
-                            '\n'
-                            '# this is\n'
-                            '# a block     \n'
-                            '# comment\n'
-                            '\n'
-                            'other:\n'
-                            '  - foo  # equals\n'
-                            '         # bar\n',
-                            Comment(1, 1, '# comment one', 0),
-                            Comment(3, 11, '# key=val', 0),
-                            Comment(5, 1, '# this is', 0),
-                            Comment(6, 1, '# a block     ', 0),
-                            Comment(7, 1, '# comment', 0),
-                            Comment(10, 10, '# equals', 0),
-                            Comment(11, 10, '# bar', 0))

tests/rules/test_indentation.py

@@ -15,7 +15,7 @@
 # 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.parser import token_or_comment_generator, Comment
 from yamllint.rules.indentation import check
 
 
@@ -38,7 +38,8 @@ class IndentationStackTestCase(RuleTestCase):
                 'check-multi-line-strings': False}
         context = {}
         output = ''
-        for elem in token_generator(source):
+        for elem in [t for t in token_or_comment_generator(source)
+                     if not isinstance(t, Comment)]:
             list(check(conf, elem.curr, elem.prev, elem.next, elem.nextnext,
                        context))
 
@@ -381,6 +382,141 @@ class IndentationStackTestCase(RuleTestCase):
             # missing BEnd here
             '     BEnd \n')
 
+    def test_flows_imbrication(self):
+        self.assertMultiLineEqual(
+            self.full_stack('[[val]]\n'),
+            'FSeqStart F_SEQ:1\n'
+            'FSeqStart F_SEQ:1 F_SEQ:2\n'
+            '   Scalar F_SEQ:1 F_SEQ:2\n'
+            '  FSeqEnd F_SEQ:1\n'
+            '  FSeqEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('[[val], [val2]]\n'),
+            'FSeqStart F_SEQ:1\n'
+            'FSeqStart F_SEQ:1 F_SEQ:2\n'
+            '   Scalar F_SEQ:1 F_SEQ:2\n'
+            '  FSeqEnd F_SEQ:1\n'
+            '   FEntry F_SEQ:1\n'
+            'FSeqStart F_SEQ:1 F_SEQ:9\n'
+            '   Scalar F_SEQ:1 F_SEQ:9\n'
+            '  FSeqEnd F_SEQ:1\n'
+            '  FSeqEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('{{key}}\n'),
+            'FMapStart F_MAP:1\n'
+            'FMapStart F_MAP:1 F_MAP:2\n'
+            '   Scalar F_MAP:1 F_MAP:2\n'
+            '  FMapEnd F_MAP:1\n'
+            '  FMapEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('[key]: value\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            'FSeqStart B_MAP:0 KEY:0 F_SEQ:1\n'
+            '   Scalar B_MAP:0 KEY:0 F_SEQ:1\n'
+            '  FSeqEnd B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:7\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('[[key]]: value\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            'FSeqStart B_MAP:0 KEY:0 F_SEQ:1\n'
+            'FSeqStart B_MAP:0 KEY:0 F_SEQ:1 F_SEQ:2\n'
+            '   Scalar B_MAP:0 KEY:0 F_SEQ:1 F_SEQ:2\n'
+            '  FSeqEnd B_MAP:0 KEY:0 F_SEQ:1\n'
+            '  FSeqEnd B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:9\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('{key}: value\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            'FMapStart B_MAP:0 KEY:0 F_MAP:1\n'
+            '   Scalar B_MAP:0 KEY:0 F_MAP:1\n'
+            '  FMapEnd B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:7\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('{key: value}: value\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            'FMapStart B_MAP:0 KEY:0 F_MAP:1\n'
+            '      Key B_MAP:0 KEY:0 F_MAP:1 KEY:1\n'
+            '   Scalar B_MAP:0 KEY:0 F_MAP:1 KEY:1\n'
+            '    Value B_MAP:0 KEY:0 F_MAP:1 KEY:1 VAL:6\n'
+            '   Scalar B_MAP:0 KEY:0 F_MAP:1\n'
+            '  FMapEnd B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:14\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('{{key}}: value\n'),
+            'BMapStart B_MAP:0\n'
+            '      Key B_MAP:0 KEY:0\n'
+            'FMapStart B_MAP:0 KEY:0 F_MAP:1\n'
+            'FMapStart B_MAP:0 KEY:0 F_MAP:1 F_MAP:2\n'
+            '   Scalar B_MAP:0 KEY:0 F_MAP:1 F_MAP:2\n'
+            '  FMapEnd B_MAP:0 KEY:0 F_MAP:1\n'
+            '  FMapEnd B_MAP:0 KEY:0\n'
+            '    Value B_MAP:0 KEY:0 VAL:9\n'
+            '   Scalar B_MAP:0\n'
+            '     BEnd \n')
+        self.assertMultiLineEqual(
+            self.full_stack('{{key}: val, {key2}: {val2}}\n'),
+            'FMapStart F_MAP:1\n'
+            '      Key F_MAP:1 KEY:1\n'
+            'FMapStart F_MAP:1 KEY:1 F_MAP:2\n'
+            '   Scalar F_MAP:1 KEY:1 F_MAP:2\n'
+            '  FMapEnd F_MAP:1 KEY:1\n'
+            '    Value F_MAP:1 KEY:1 VAL:8\n'
+            '   Scalar F_MAP:1\n'
+            '   FEntry F_MAP:1\n'
+            '      Key F_MAP:1 KEY:1\n'
+            'FMapStart F_MAP:1 KEY:1 F_MAP:14\n'
+            '   Scalar F_MAP:1 KEY:1 F_MAP:14\n'
+            '  FMapEnd F_MAP:1 KEY:1\n'
+            '    Value F_MAP:1 KEY:1 VAL:21\n'
+            'FMapStart F_MAP:1 KEY:1 VAL:21 F_MAP:22\n'
+            '   Scalar F_MAP:1 KEY:1 VAL:21 F_MAP:22\n'
+            '  FMapEnd F_MAP:1\n'
+            '  FMapEnd \n')
+
+        self.assertMultiLineEqual(
+            self.full_stack('{[{{[val]}}, [{[key]: val2}]]}\n'),
+            'FMapStart F_MAP:1\n'
+            'FSeqStart F_MAP:1 F_SEQ:2\n'
+            'FMapStart F_MAP:1 F_SEQ:2 F_MAP:3\n'
+            'FMapStart F_MAP:1 F_SEQ:2 F_MAP:3 F_MAP:4\n'
+            'FSeqStart F_MAP:1 F_SEQ:2 F_MAP:3 F_MAP:4 F_SEQ:5\n'
+            '   Scalar F_MAP:1 F_SEQ:2 F_MAP:3 F_MAP:4 F_SEQ:5\n'
+            '  FSeqEnd F_MAP:1 F_SEQ:2 F_MAP:3 F_MAP:4\n'
+            '  FMapEnd F_MAP:1 F_SEQ:2 F_MAP:3\n'
+            '  FMapEnd F_MAP:1 F_SEQ:2\n'
+            '   FEntry F_MAP:1 F_SEQ:2\n'
+            'FSeqStart F_MAP:1 F_SEQ:2 F_SEQ:14\n'
+            'FMapStart F_MAP:1 F_SEQ:2 F_SEQ:14 F_MAP:15\n'
+            '      Key F_MAP:1 F_SEQ:2 F_SEQ:14 F_MAP:15 KEY:15\n'
+            'FSeqStart F_MAP:1 F_SEQ:2 F_SEQ:14 F_MAP:15 KEY:15 F_SEQ:16\n'
+            '   Scalar F_MAP:1 F_SEQ:2 F_SEQ:14 F_MAP:15 KEY:15 F_SEQ:16\n'
+            '  FSeqEnd F_MAP:1 F_SEQ:2 F_SEQ:14 F_MAP:15 KEY:15\n'
+            '    Value F_MAP:1 F_SEQ:2 F_SEQ:14 F_MAP:15 KEY:15 VAL:22\n'
+            '   Scalar F_MAP:1 F_SEQ:2 F_SEQ:14 F_MAP:15\n'
+            '  FMapEnd F_MAP:1 F_SEQ:2 F_SEQ:14\n'
+            '  FSeqEnd F_MAP:1 F_SEQ:2\n'
+            '  FSeqEnd F_MAP:1\n'
+            '  FMapEnd \n')
+
 
 class IndentationTestCase(RuleTestCase):
     rule_id = 'indentation'
@@ -615,10 +751,60 @@ class IndentationTestCase(RuleTestCase):
                    '- b\n'
                    '- c\n', conf, problem=(6, 1, 'syntax'))
 
+    def test_indent_sequences_consistent(self):
+        conf = 'indentation: {spaces: 4, indent-sequences: consistent}'
+        self.check('---\n'
+                   'list one:\n'
+                   '- 1\n'
+                   '- 2\n'
+                   '- 3\n'
+                   'list:\n'
+                   '    two:\n'
+                   '    - a\n'
+                   '    - b\n'
+                   '    - c\n', conf)
+        self.check('---\n'
+                   'list one:\n'
+                   '    - 1\n'
+                   '    - 2\n'
+                   '    - 3\n'
+                   'list:\n'
+                   '    two:\n'
+                   '        - a\n'
+                   '        - b\n'
+                   '        - c\n', conf)
+        self.check('---\n'
+                   'list one:\n'
+                   '- 1\n'
+                   '- 2\n'
+                   '- 3\n'
+                   'list two:\n'
+                   '    - a\n'
+                   '    - b\n'
+                   '    - c\n', conf, problem=(7, 5))
+        self.check('---\n'
+                   'list one:\n'
+                   '    - 1\n'
+                   '    - 2\n'
+                   '    - 3\n'
+                   'list two:\n'
+                   '- a\n'
+                   '- b\n'
+                   '- c\n', conf, problem=(7, 1))
+        self.check('---\n'
+                   'list one:\n'
+                   ' - 1\n'
+                   ' - 2\n'
+                   ' - 3\n'
+                   'list two:\n'
+                   '- a\n'
+                   '- b\n'
+                   '- c\n', conf, problem1=(3, 2), problem2=(7, 1))
+
     def test_direct_flows(self):
         # flow: [ ...
         # ]
-        conf = 'indentation: {spaces: 2}'
+        conf = 'indentation: {spaces: consistent}'
         self.check('---\n'
                    'a: {x: 1,\n'
                    '    y,\n'
@@ -670,7 +856,7 @@ class IndentationTestCase(RuleTestCase):
         # flow: [
         #   ...
         # ]
-        conf = 'indentation: {spaces: 2}'
+        conf = 'indentation: {spaces: consistent}'
         self.check('---\n'
                    'a: {\n'
                    '  x: 1,\n'
@@ -684,7 +870,7 @@ class IndentationTestCase(RuleTestCase):
                    'a: {\n'
                    '   x: 1,\n'
                    '  y, z: 1\n'
-                   '}\n', conf, problem=(3, 4))
+                   '}\n', conf, problem=(4, 3))
         self.check('---\n'
                    'a: {\n'
                    '  x: 1,\n'
@@ -703,7 +889,7 @@ class IndentationTestCase(RuleTestCase):
                    'a: [\n'
                    '   x,\n'
                    '  y, z\n'
-                   ']\n', conf, problem=(3, 4))
+                   ']\n', conf, problem=(4, 3))
         self.check('---\n'
                    'a: [\n'
                    '  x,\n'
@@ -752,13 +938,24 @@ class IndentationTestCase(RuleTestCase):
                    '      foo: 1,\n'
                    '      bar: 2\n'
                    '  }\n', conf, problem1=(7, 7), problem2=(11, 3))
+        conf = 'indentation: {spaces: 2}'
+        self.check('---\n'
+                   'a: {\n'
+                   '   x: 1,\n'
+                   '  y, z: 1\n'
+                   '}\n', conf, problem=(3, 4))
+        self.check('---\n'
+                   'a: [\n'
+                   '   x,\n'
+                   '  y, z\n'
+                   ']\n', conf, problem=(3, 4))
 
     def test_cleared_flows(self):
         # flow:
         #   [
         #     ...
         #   ]
-        conf = 'indentation: {spaces: 2}'
+        conf = 'indentation: {spaces: consistent}'
         self.check('---\n'
                    'top:\n'
                    '  rules:\n'
@@ -808,7 +1005,7 @@ class IndentationTestCase(RuleTestCase):
                    'top:\n'
                    '   [\n'
                    '     a, b, c\n'
-                   '   ]\n', conf, problem=(3, 4))
+                   '   ]\n', conf, problem=(4, 6))
         self.check('---\n'
                    'top:\n'
                    '  [\n'
@@ -843,7 +1040,7 @@ class IndentationTestCase(RuleTestCase):
                    problem3=(9, 9), problem4=(11, 7), problem5=(13, 1))
 
     def test_under_indented(self):
-        conf = 'indentation: {spaces: 2, indent-sequences: yes}'
+        conf = 'indentation: {spaces: 2, indent-sequences: consistent}'
         self.check('---\n'
                    'object:\n'
                    ' val: 1\n'
@@ -859,7 +1056,7 @@ class IndentationTestCase(RuleTestCase):
                    '    - name: Unix\n'
                    '     date: 1969\n'
                    '...\n', conf, problem=(5, 6, 'syntax'))
-        conf = 'indentation: {spaces: 4, indent-sequences: yes}'
+        conf = 'indentation: {spaces: 4, indent-sequences: consistent}'
         self.check('---\n'
                    'object:\n'
                    '   val: 1\n'
@@ -877,7 +1074,7 @@ class IndentationTestCase(RuleTestCase):
                    '...\n', conf, problem=(5, 10, 'syntax'))
 
     def test_over_indented(self):
-        conf = 'indentation: {spaces: 2, indent-sequences: yes}'
+        conf = 'indentation: {spaces: 2, indent-sequences: consistent}'
         self.check('---\n'
                    'object:\n'
                    '   val: 1\n'
@@ -893,7 +1090,7 @@ class IndentationTestCase(RuleTestCase):
                    '    - name: Unix\n'
                    '       date: 1969\n'
                    '...\n', conf, problem=(5, 12, 'syntax'))
-        conf = 'indentation: {spaces: 4, indent-sequences: yes}'
+        conf = 'indentation: {spaces: 4, indent-sequences: consistent}'
         self.check('---\n'
                    'object:\n'
                    '     val: 1\n'
@@ -933,7 +1130,7 @@ class IndentationTestCase(RuleTestCase):
                    problem=(2, 3))
 
     def test_multi_lines(self):
-        conf = 'indentation: {spaces: 2, indent-sequences: yes}'
+        conf = 'indentation: {spaces: consistent, indent-sequences: yes}'
         self.check('---\n'
                    'long_string: >\n'
                    '  bla bla blah\n'
@@ -952,7 +1149,7 @@ class IndentationTestCase(RuleTestCase):
                    '...\n', conf)
 
     def test_empty_value(self):
-        conf = 'indentation: {spaces: 2}'
+        conf = 'indentation: {spaces: consistent}'
         self.check('---\n'
                    'key1:\n'
                    'key2: not empty\n'
@@ -1007,7 +1204,7 @@ class IndentationTestCase(RuleTestCase):
                    '...\n', conf, problem=(2, 2))
 
     def test_return(self):
-        conf = 'indentation: {spaces: 2}'
+        conf = 'indentation: {spaces: consistent}'
         self.check('---\n'
                    'a:\n'
                    '  b:\n'
@@ -1031,18 +1228,52 @@ class IndentationTestCase(RuleTestCase):
                    '...\n', conf, problem=(5, 2, 'syntax'))
 
     def test_first_line(self):
-        conf = ('indentation: {spaces: 2}\n'
+        conf = ('indentation: {spaces: consistent}\n'
                 'document-start: disable\n')
         self.check('  a: 1\n', conf, problem=(1, 3))
 
     def test_explicit_block_mappings(self):
-        conf = 'indentation: {spaces: 4}'
+        conf = 'indentation: {spaces: consistent}'
+        self.check('---\n'
+                   'object:\n'
+                   '    ? key\n'
+                   '    : value\n', conf)
         self.check('---\n'
                    'object:\n'
                    '    ? key\n'
                    '    :\n'
                    '        value\n'
                    '...\n', conf)
+        self.check('---\n'
+                   'object:\n'
+                   '    ?\n'
+                   '        key\n'
+                   '    : value\n', conf)
+        self.check('---\n'
+                   'object:\n'
+                   '    ?\n'
+                   '        key\n'
+                   '    :\n'
+                   '        value\n'
+                   '...\n', conf)
+        self.check('---\n'
+                   '- ? key\n'
+                   '  : value\n', conf)
+        self.check('---\n'
+                   '- ? key\n'
+                   '  :\n'
+                   '      value\n'
+                   '...\n', conf)
+        self.check('---\n'
+                   '- ?\n'
+                   '      key\n'
+                   '  : value\n', conf)
+        self.check('---\n'
+                   '- ?\n'
+                   '      key\n'
+                   '  :\n'
+                   '      value\n'
+                   '...\n', conf)
         self.check('---\n'
                    'object:\n'
                    '    ? key\n'
@@ -1050,12 +1281,11 @@ class IndentationTestCase(RuleTestCase):
                    '       value\n'
                    '...\n', conf, problem=(5, 8))
         self.check('---\n'
-                   'object:\n'
-                   '    ?\n'
-                   '        key\n'
+                   '- - ?\n'
+                   '       key\n'
                    '    :\n'
-                   '        value\n'
-                   '...\n', conf)
+                   '      value\n'
+                   '...\n', conf, problem=(5, 7))
         self.check('---\n'
                    'object:\n'
                    '    ?\n'
@@ -1072,7 +1302,7 @@ class IndentationTestCase(RuleTestCase):
                    '...\n', conf, problem1=(4, 10), problem2=(6, 8))
 
     def test_clear_sequence_item(self):
-        conf = 'indentation: {spaces: 2}'
+        conf = 'indentation: {spaces: consistent}'
         self.check('---\n'
                    '-\n'
                    '  string\n'
@@ -1087,6 +1317,35 @@ class IndentationTestCase(RuleTestCase):
                    '      multi\n'
                    '      line\n'
                    '...\n', conf)
+        self.check('---\n'
+                   '-\n'
+                   ' string\n'
+                   '-\n'
+                   '   string\n', conf, problem=(5, 4))
+        self.check('---\n'
+                   '-\n'
+                   ' map: ping\n'
+                   '-\n'
+                   '   map: ping\n', conf, problem=(5, 4))
+        self.check('---\n'
+                   '-\n'
+                   ' - sequence\n'
+                   '-\n'
+                   '   - sequence\n', conf, problem=(5, 4))
+        self.check('---\n'
+                   '-\n'
+                   '  -\n'
+                   '   nested\n'
+                   '  -\n'
+                   '     nested\n', conf, problem1=(4, 4), problem2=(6, 6))
+        self.check('---\n'
+                   '-\n'
+                   '  -\n'
+                   '     >\n'
+                   '      multi\n'
+                   '      line\n'
+                   '...\n', conf, problem=(4, 6))
+        conf = 'indentation: {spaces: 2}'
         self.check('---\n'
                    '-\n'
                    ' string\n'
@@ -1108,16 +1367,9 @@ class IndentationTestCase(RuleTestCase):
                    '   nested\n'
                    '  -\n'
                    '     nested\n', conf, problem1=(4, 4), problem2=(6, 6))
-        self.check('---\n'
-                   '-\n'
-                   '  -\n'
-                   '     >\n'
-                   '      multi\n'
-                   '      line\n'
-                   '...\n', conf, problem=(4, 6))
 
     def test_anchors(self):
-        conf = 'indentation: {spaces: 2}'
+        conf = 'indentation: {spaces: consistent}'
         self.check('---\n'
                    'key: &anchor value\n', conf)
         self.check('---\n'
@@ -1177,7 +1429,7 @@ class IndentationTestCase(RuleTestCase):
                    '  - k: *a\n', conf)
 
     def test_tags(self):
-        conf = 'indentation: {spaces: 2}'
+        conf = 'indentation: {spaces: consistent}'
         self.check('---\n'
                    '-\n'
                    '  "flow in block"\n'
@@ -1186,7 +1438,7 @@ class IndentationTestCase(RuleTestCase):
                    '- !!map  # Block collection\n'
                    '  foo: bar\n', conf)
 
-        conf = 'indentation: {spaces: 2, indent-sequences: no}'
+        conf = 'indentation: {spaces: consistent, indent-sequences: no}'
         self.check('---\n'
                    'sequence: !!seq\n'
                    '- entry\n'
@@ -1205,12 +1457,55 @@ class IndentationTestCase(RuleTestCase):
                    '- Clark Evans\n'
                    '- Ingy döt Net\n', conf)
 
+    def test_flows_imbrication(self):
+        conf = 'indentation: {spaces: consistent}'
+        self.check('---\n'
+                   '[val]: value\n', conf)
+        self.check('---\n'
+                   '{key}: value\n', conf)
+        self.check('---\n'
+                   '{key: val}: value\n', conf)
+        self.check('---\n'
+                   '[[val]]: value\n', conf)
+        self.check('---\n'
+                   '{{key}}: value\n', conf)
+        self.check('---\n'
+                   '{{key: val1}: val2}: value\n', conf)
+        self.check('---\n'
+                   '- [val, {{key: val}: val}]: value\n'
+                   '- {[val,\n'
+                   '    {{key: val}: val}]}\n'
+                   '- {[val,\n'
+                   '    {{key: val,\n'
+                   '      key2}}]}\n'
+                   '- {{{{{moustaches}}}}}\n'
+                   '- {{{{{moustache,\n'
+                   '       moustache},\n'
+                   '      moustache}},\n'
+                   '    moustache}}\n', conf)
+        self.check('---\n'
+                   '- {[val,\n'
+                   '     {{key: val}: val}]}\n',
+                   conf, problem=(3, 6))
+        self.check('---\n'
+                   '- {[val,\n'
+                   '    {{key: val,\n'
+                   '     key2}}]}\n',
+                   conf, problem=(4, 6))
+        self.check('---\n'
+                   '- {{{{{moustache,\n'
+                   '       moustache},\n'
+                   '       moustache}},\n'
+                   '   moustache}}\n',
+                   conf, problem1=(4, 8), problem2=(5, 4))
+
 
 class ScalarIndentationTestCase(RuleTestCase):
     rule_id = 'indentation'
 
     def test_basics_plain(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: no}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: no}\n'
                 'document-start: disable\n')
         self.check('multi\n'
                    'line\n', conf)
@@ -1238,7 +1533,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    '    }\n', conf)
 
     def test_check_multi_line_plain(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: yes}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('multi\n'
                    ' line\n', conf, problem=(2, 2))
@@ -1260,7 +1556,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    '    }\n', conf, problem=(3, 9))
 
     def test_basics_quoted(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: no}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: no}\n'
                 'document-start: disable\n')
         self.check('"multi\n'
                    ' line"\n', conf)
@@ -1290,7 +1587,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    '            line 2"]\n', conf)
 
     def test_check_multi_line_quoted(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: yes}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('"multi\n'
                    'line"\n', conf, problem=(2, 1))
@@ -1345,7 +1643,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    '             line 2"]\n', conf, problem=(3, 14))
 
     def test_basics_folded_style(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: no}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: no}\n'
                 'document-start: disable\n')
         self.check('>\n'
                    '  multi\n'
@@ -1382,7 +1681,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    '    {% endif %}\n', conf)
 
     def test_check_multi_line_folded_style(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: yes}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('>\n'
                    '  multi\n'
@@ -1422,7 +1722,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    problem1=(3, 7), problem2=(5, 7))
 
     def test_basics_literal_style(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: no}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: no}\n'
                 'document-start: disable\n')
         self.check('|\n'
                    '  multi\n'
@@ -1459,7 +1760,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    '    {% endif %}\n', conf)
 
     def test_check_multi_line_literal_style(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: yes}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('|\n'
                    '  multi\n'
@@ -1502,7 +1804,8 @@ class ScalarIndentationTestCase(RuleTestCase):
     # http://stackoverflow.com/questions/3790454/in-yaml-how-do-i-break-a-string-over-multiple-lines
 
     def test_paragraph_plain(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: yes}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('- long text: very "long"\n'
                    '             \'string\' with\n'
@@ -1523,7 +1826,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    '    spaces.\n', conf)
 
     def test_paragraph_double_quoted(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: yes}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('- long text: "very \\"long\\"\n'
                    '              \'string\' with\n'
@@ -1550,7 +1854,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    '     spaces."\n', conf)
 
     def test_paragraph_single_quoted(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: yes}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('- long text: \'very "long"\n'
                    '              \'\'string\'\' with\n'
@@ -1577,7 +1882,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    '     spaces.\'\n', conf)
 
     def test_paragraph_folded(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: yes}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('- long text: >\n'
                    '    very "long"\n'
@@ -1594,7 +1900,8 @@ class ScalarIndentationTestCase(RuleTestCase):
                    problem1=(3, 6), problem2=(5, 7), problem3=(6, 8))
 
     def test_paragraph_literal(self):
-        conf = ('indentation: {spaces: 2, check-multi-line-strings: yes}\n'
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('- long text: |\n'
                    '    very "long"\n'

tests/rules/test_key_duplicates.py

@@ -80,7 +80,7 @@ class KeyDuplicatesTestCase(RuleTestCase):
                    ': 1\n', conf)
 
     def test_enabled(self):
-        conf = 'key-duplicates: {}'
+        conf = 'key-duplicates: enable'
         self.check('---\n'
                    'block mapping:\n'
                    '  key: a\n'
@@ -149,7 +149,7 @@ class KeyDuplicatesTestCase(RuleTestCase):
                    problem4=(7, 3))
 
     def test_key_tokens_in_flow_sequences(self):
-        conf = 'key-duplicates: {}'
+        conf = 'key-duplicates: enable'
         self.check('---\n'
                    '[\n'
                    '  flow: sequence, with, key: value, mappings\n'

tests/rules/test_line_length.py

@@ -78,6 +78,12 @@ class LineLengthTestCase(RuleTestCase):
                    '        # http://localhost/very/long/url\n'
                    '        comment\n'
                    '...\n', conf)
+        self.check('---\n'
+                   'this:\n'
+                   'is:\n'
+                   'another:\n'
+                   '  - https://localhost/very/very/long/url\n'
+                   '...\n', conf)
 
         conf = 'line-length: {max: 20, allow-non-breakable-words: no}'
         self.check('---\n' + 30 * 'A' + '\n', conf, problem=(2, 21))
@@ -94,3 +100,9 @@ class LineLengthTestCase(RuleTestCase):
                    '        # http://localhost/very/long/url\n'
                    '        comment\n'
                    '...\n', conf, problem=(5, 21))
+        self.check('---\n'
+                   'this:\n'
+                   'is:\n'
+                   'another:\n'
+                   '  - https://localhost/very/very/long/url\n'
+                   '...\n', conf, problem=(5, 21))

tests/rules/test_new_line_at_end_of_file.py

@@ -30,7 +30,7 @@ class NewLineAtEndOfFileTestCase(RuleTestCase):
         self.check('Sentence.\n', conf)
 
     def test_enabled(self):
-        conf = ('new-line-at-end-of-file: {}\n'
+        conf = ('new-line-at-end-of-file: enable\n'
                 'empty-lines: disable\n'
                 'document-start: disable\n')
         self.check('', conf)

tests/rules/test_trailing_spaces.py

@@ -29,7 +29,7 @@ class TrailingSpacesTestCase(RuleTestCase):
                    'some: text \n', conf)
 
     def test_enabled(self):
-        conf = 'trailing-spaces: {}'
+        conf = 'trailing-spaces: enable'
         self.check('', conf)
         self.check('\n', conf)
         self.check('    \n', conf, problem=(1, 1))
@@ -40,7 +40,7 @@ class TrailingSpacesTestCase(RuleTestCase):
                    'some: text\t\n', conf, problem=(2, 11, 'syntax'))
 
     def test_with_dos_new_lines(self):
-        conf = ('trailing-spaces: {}\n'
+        conf = ('trailing-spaces: enable\n'
                 'new-lines: {type: dos}\n')
         self.check('---\r\n'
                    'some: text\r\n', conf)

tests/test_cli.py

@@ -0,0 +1,299 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2016 Adrien Vergé
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from io import StringIO
+import os
+import shutil
+import tempfile
+import unittest
+import sys
+
+from yamllint import cli
+
+
+class CommandLineTestCase(unittest.TestCase):
+    def setUp(self):
+        self.wd = tempfile.mkdtemp(prefix='yamllint-tests-')
+
+        # .yaml file at root
+        with open(os.path.join(self.wd, 'a.yaml'), 'w') as f:
+            f.write('---\n'
+                    '- 1   \n'
+                    '- 2')
+
+        # .yml file at root
+        open(os.path.join(self.wd, 'empty.yml'), 'w').close()
+
+        # file in dir
+        os.mkdir(os.path.join(self.wd, 'sub'))
+        with open(os.path.join(self.wd, 'sub', 'ok.yaml'), 'w') as f:
+            f.write('---\n'
+                    'key: value\n')
+
+        # file in very nested dir
+        dir = self.wd
+        for i in range(15):
+            dir = os.path.join(dir, 's')
+            os.mkdir(dir)
+        with open(os.path.join(dir, 'file.yaml'), 'w') as f:
+            f.write('---\n'
+                    'key: value\n'
+                    'key: other value\n')
+
+        # empty dir
+        os.mkdir(os.path.join(self.wd, 'empty-dir'))
+
+        # non-YAML file
+        with open(os.path.join(self.wd, 'no-yaml.json'), 'w') as f:
+            f.write('---\n'
+                    'key: value\n')
+
+    def tearDown(self):
+        shutil.rmtree(self.wd)
+
+    def test_find_files_recursively(self):
+        self.assertEqual(
+            sorted(cli.find_files_recursively([self.wd])),
+            [os.path.join(self.wd, 'a.yaml'),
+             os.path.join(self.wd, 'empty.yml'),
+             os.path.join(self.wd, 's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'),
+             os.path.join(self.wd, 'sub/ok.yaml')],
+        )
+
+        items = [os.path.join(self.wd, 'sub/ok.yaml'),
+                 os.path.join(self.wd, 'empty-dir')]
+        self.assertEqual(
+            sorted(cli.find_files_recursively(items)),
+            [os.path.join(self.wd, 'sub/ok.yaml')],
+        )
+
+        items = [os.path.join(self.wd, 'empty.yml'),
+                 os.path.join(self.wd, 's')]
+        self.assertEqual(
+            sorted(cli.find_files_recursively(items)),
+            [os.path.join(self.wd, 'empty.yml'),
+             os.path.join(self.wd, 's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml')],
+        )
+
+        items = [os.path.join(self.wd, 'sub'),
+                 os.path.join(self.wd, '/etc/another/file')]
+        self.assertEqual(
+            sorted(cli.find_files_recursively(items)),
+            [os.path.join(self.wd, '/etc/another/file'),
+             os.path.join(self.wd, 'sub/ok.yaml')],
+        )
+
+    def test_run_with_bad_arguments(self):
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(())
+
+        self.assertNotEqual(ctx.exception.code, 0)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, '')
+        self.assertRegexpMatches(err, r'^usage')
+
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('--unknown-arg', ))
+
+        self.assertNotEqual(ctx.exception.code, 0)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, '')
+        self.assertRegexpMatches(err, r'^usage')
+
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-c', './conf.yaml', '-d', 'relaxed', 'file'))
+
+        self.assertNotEqual(ctx.exception.code, 0)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, '')
+        self.assertRegexpMatches(err, r'^Options --config-file and '
+                                      r'--config-data cannot be used')
+
+    def test_run_with_bad_config(self):
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-d', 'rules: {a: b}', 'file'))
+
+        self.assertEqual(ctx.exception.code, -1)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, '')
+        self.assertRegexpMatches(err, r'^invalid config: no such rule')
+
+    def test_run_with_empty_config(self):
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-d', '', 'file'))
+
+        self.assertEqual(ctx.exception.code, -1)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, '')
+        self.assertRegexpMatches(err, r'^invalid config: not a dict')
+
+    def test_run_with_config_file(self):
+        with open(os.path.join(self.wd, 'config'), 'w') as f:
+            f.write('rules: {trailing-spaces: disable}')
+
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-c', f.name, os.path.join(self.wd, 'a.yaml')))
+        self.assertEqual(ctx.exception.code, 0)
+
+        with open(os.path.join(self.wd, 'config'), 'w') as f:
+            f.write('rules: {trailing-spaces: enable}')
+
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-c', f.name, os.path.join(self.wd, 'a.yaml')))
+        self.assertEqual(ctx.exception.code, 1)
+
+    def test_run_with_user_global_config_file(self):
+        home = os.path.join(self.wd, 'fake-home')
+        os.mkdir(home)
+        dir = os.path.join(home, '.config')
+        os.mkdir(dir)
+        dir = os.path.join(dir, 'yamllint')
+        os.mkdir(dir)
+        config = os.path.join(dir, 'config')
+
+        temp = os.environ['HOME']
+        os.environ['HOME'] = home
+
+        with open(config, 'w') as f:
+            f.write('rules: {trailing-spaces: disable}')
+
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run((os.path.join(self.wd, 'a.yaml'), ))
+        self.assertEqual(ctx.exception.code, 0)
+
+        with open(config, 'w') as f:
+            f.write('rules: {trailing-spaces: enable}')
+
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run((os.path.join(self.wd, 'a.yaml'), ))
+        self.assertEqual(ctx.exception.code, 1)
+
+        os.environ['HOME'] = temp
+
+    def test_run_version(self):
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('--version', ))
+
+        self.assertEqual(ctx.exception.code, 0)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertRegexpMatches(out + err, r'yamllint \d+\.\d+')
+
+    def test_run_non_existing_file(self):
+        file = os.path.join(self.wd, 'i-do-not-exist.yaml')
+
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', file))
+
+        self.assertEqual(ctx.exception.code, -1)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, '')
+        self.assertRegexpMatches(err, r'No such file or directory')
+
+    def test_run_one_problem_file(self):
+        file = os.path.join(self.wd, 'a.yaml')
+
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', file))
+
+        self.assertEqual(ctx.exception.code, 1)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, (
+            '%s:2:4: [error] trailing spaces (trailing-spaces)\n'
+            '%s:3:4: [error] no new line character at the end of file '
+            '(new-line-at-end-of-file)\n') % (file, file))
+        self.assertEqual(err, '')
+
+    def test_run_one_ok_file(self):
+        file = os.path.join(self.wd, 'sub', 'ok.yaml')
+
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', file))
+
+        self.assertEqual(ctx.exception.code, 0)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, '')
+        self.assertEqual(err, '')
+
+    def test_run_empty_file(self):
+        file = os.path.join(self.wd, 'empty.yml')
+
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', file))
+
+        self.assertEqual(ctx.exception.code, 0)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, '')
+        self.assertEqual(err, '')
+
+    def test_run_multiple_files(self):
+        items = [os.path.join(self.wd, 'empty.yml'),
+                 os.path.join(self.wd, 's')]
+        file = items[1] + '/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'
+
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(['-f', 'parsable'] + items)
+
+        self.assertEqual(ctx.exception.code, 1)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, (
+            '%s:3:1: [error] duplication of key "key" in mapping '
+            '(key-duplicates)\n') % file)
+        self.assertEqual(err, '')
+
+    def test_run_colored_output(self):
+        file = os.path.join(self.wd, 'a.yaml')
+
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run((file, ))
+
+        self.assertEqual(ctx.exception.code, 1)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, (
+            '\033[4m%s\033[0m\n'
+            '  \033[2m2:4\033[0m       \033[31merror\033[0m    '
+            'trailing spaces  \033[2m(trailing-spaces)\033[0m\n'
+            '  \033[2m3:4\033[0m       \033[31merror\033[0m    '
+            'no new line character at the end of file  '
+            '\033[2m(new-line-at-end-of-file)\033[0m\n'
+            '\n' % file))
+        self.assertEqual(err, '')

tests/test_config.py

@@ -32,12 +32,16 @@ class SimpleConfigTestCase(unittest.TestCase):
 
         self.assertEqual(len(new.enabled_rules()), 1)
 
+    def test_invalid_conf(self):
+        with self.assertRaises(config.YamlLintConfigError):
+            config.YamlLintConfig('not: valid: yaml')
+
     def test_unknown_rule(self):
         with self.assertRaisesRegexp(
                 config.YamlLintConfigError,
                 'invalid config: no such rule: "this-one-does-not-exist"'):
             config.YamlLintConfig('rules:\n'
-                                  '  this-one-does-not-exist: {}\n')
+                                  '  this-one-does-not-exist: enable\n')
 
     def test_missing_option(self):
         with self.assertRaisesRegexp(
@@ -65,6 +69,11 @@ class SimpleConfigTestCase(unittest.TestCase):
         self.assertEqual(config.validate_rule_conf(Rule, False), False)
         self.assertEqual(config.validate_rule_conf(Rule, 'disable'), False)
 
+        self.assertEqual(config.validate_rule_conf(Rule, {}),
+                         {'level': 'error'})
+        self.assertEqual(config.validate_rule_conf(Rule, 'enable'),
+                         {'level': 'error'})
+
         config.validate_rule_conf(Rule, {'level': 'error'})
         config.validate_rule_conf(Rule, {'level': 'warning'})
         self.assertRaises(config.YamlLintConfigError,

tests/test_parser.py

@@ -18,8 +18,9 @@ import unittest
 
 import yaml
 
-from yamllint.parser import (line_generator, token_generator,
-                             token_or_line_generator, Line, Token)
+from yamllint.parser import (line_generator, token_or_comment_generator,
+                             token_or_comment_or_line_generator,
+                             Line, Token, Comment)
 
 
 class ParserTestCase(unittest.TestCase):
@@ -61,8 +62,8 @@ class ParserTestCase(unittest.TestCase):
         self.assertEqual(e[2].line_no, 3)
         self.assertEqual(e[2].content, 'at the end')
 
-    def test_token_generator(self):
-        e = list(token_generator(''))
+    def test_token_or_comment_generator(self):
+        e = list(token_or_comment_generator(''))
         self.assertEqual(len(e), 2)
         self.assertEqual(e[0].prev, None)
         self.assertIsInstance(e[0].curr, yaml.Token)
@@ -71,16 +72,74 @@ class ParserTestCase(unittest.TestCase):
         self.assertEqual(e[1].curr, e[0].next)
         self.assertEqual(e[1].next, None)
 
-        e = list(token_generator('---\n'
-                                 'k: v\n'))
+        e = list(token_or_comment_generator('---\n'
+                                            'k: v\n'))
         self.assertEqual(len(e), 9)
         self.assertIsInstance(e[3].curr, yaml.KeyToken)
         self.assertIsInstance(e[5].curr, yaml.ValueToken)
 
-    def test_token_or_line_generator(self):
-        e = list(token_or_line_generator('---\n'
-                                         'k: v\n'))
-        self.assertEqual(len(e), 12)
+        e = list(token_or_comment_generator('# start comment\n'
+                                            '- a\n'
+                                            '- key: val  # key=val\n'
+                                            '# this is\n'
+                                            '# a block     \n'
+                                            '# comment\n'
+                                            '- c\n'
+                                            '# end comment\n'))
+        self.assertEqual(len(e), 21)
+        self.assertIsInstance(e[1], Comment)
+        self.assertEqual(e[1], Comment(1, 1, '# start comment', 0))
+        self.assertEqual(e[11], Comment(3, 13, '# key=val', 0))
+        self.assertEqual(e[12], Comment(4, 1, '# this is', 0))
+        self.assertEqual(e[13], Comment(5, 1, '# a block     ', 0))
+        self.assertEqual(e[14], Comment(6, 1, '# comment', 0))
+        self.assertEqual(e[18], Comment(8, 1, '# end comment', 0))
+
+        e = list(token_or_comment_generator('---\n'
+                                            '# no newline char'))
+        self.assertEqual(e[2], Comment(2, 1, '# no newline char', 0))
+
+        e = list(token_or_comment_generator('# just comment'))
+        self.assertEqual(e[1], Comment(1, 1, '# just comment', 0))
+
+        e = list(token_or_comment_generator('\n'
+                                            '   # indented comment\n'))
+        self.assertEqual(e[1], Comment(2, 4, '# indented comment', 0))
+
+        e = list(token_or_comment_generator('\n'
+                                            '# trailing spaces    \n'))
+        self.assertEqual(e[1], Comment(2, 1, '# trailing spaces    ', 0))
+
+        e = [c for c in
+             token_or_comment_generator('# block\n'
+                                        '# comment\n'
+                                        '- data   # inline comment\n'
+                                        '# block\n'
+                                        '# comment\n'
+                                        '- k: v   # inline comment\n'
+                                        '- [ l, ist\n'
+                                        ']   # inline comment\n'
+                                        '- { m: ap\n'
+                                        '}   # inline comment\n'
+                                        '# block comment\n'
+                                        '- data   # inline comment\n')
+             if isinstance(c, Comment)]
+        self.assertEqual(len(e), 10)
+        self.assertFalse(e[0].is_inline())
+        self.assertFalse(e[1].is_inline())
+        self.assertTrue(e[2].is_inline())
+        self.assertFalse(e[3].is_inline())
+        self.assertFalse(e[4].is_inline())
+        self.assertTrue(e[5].is_inline())
+        self.assertTrue(e[6].is_inline())
+        self.assertTrue(e[7].is_inline())
+        self.assertFalse(e[8].is_inline())
+        self.assertTrue(e[9].is_inline())
+
+    def test_token_or_comment_or_line_generator(self):
+        e = list(token_or_comment_or_line_generator('---\n'
+                                                    'k: v  # k=v\n'))
+        self.assertEqual(len(e), 13)
         self.assertIsInstance(e[0], Token)
         self.assertIsInstance(e[0].curr, yaml.StreamStartToken)
         self.assertIsInstance(e[1], Token)
@@ -89,5 +148,6 @@ class ParserTestCase(unittest.TestCase):
         self.assertIsInstance(e[3].curr, yaml.BlockMappingStartToken)
         self.assertIsInstance(e[4].curr, yaml.KeyToken)
         self.assertIsInstance(e[6].curr, yaml.ValueToken)
-        self.assertIsInstance(e[8], Line)
-        self.assertIsInstance(e[11], Line)
+        self.assertIsInstance(e[8], Comment)
+        self.assertIsInstance(e[9], Line)
+        self.assertIsInstance(e[12], Line)

tests/test_yamllint_directives.py

@@ -0,0 +1,304 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2016 Adrien Vergé
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from tests.common import RuleTestCase
+
+
+class YamllintDirectivesTestCase(RuleTestCase):
+    conf = ('commas: disable\n'
+            'trailing-spaces: {}\n'
+            'colons: {max-spaces-before: 1}\n')
+
+    def test_disable_directive(self):
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(3, 18, 'trailing-spaces'),
+                   problem2=(4, 8, 'colons'),
+                   problem3=(6, 7, 'colons'),
+                   problem4=(6, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces    \n'
+                   '# yamllint disable\n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem=(3, 18, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint disable\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint enable\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(8, 7, 'colons'),
+                   problem2=(8, 26, 'trailing-spaces'))
+
+    def test_disable_directive_with_rules(self):
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces    \n'
+                   '# yamllint disable rule:trailing-spaces\n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(3, 18, 'trailing-spaces'),
+                   problem2=(5, 8, 'colons'),
+                   problem3=(7, 7, 'colons'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint disable rule:trailing-spaces\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint enable rule:trailing-spaces\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(5, 8, 'colons'),
+                   problem2=(8, 7, 'colons'),
+                   problem3=(8, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint disable rule:trailing-spaces\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint enable\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(5, 8, 'colons'),
+                   problem2=(8, 7, 'colons'),
+                   problem3=(8, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint disable\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint enable rule:trailing-spaces\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem=(8, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint disable rule:colons\n'
+                   '- trailing spaces    \n'
+                   '# yamllint disable rule:trailing-spaces\n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint enable rule:colons\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(4, 18, 'trailing-spaces'),
+                   problem2=(9, 7, 'colons'))
+
+    def test_disable_line_directive(self):
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces    \n'
+                   '# yamllint disable-line\n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(3, 18, 'trailing-spaces'),
+                   problem2=(7, 7, 'colons'),
+                   problem3=(7, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon  # yamllint disable-line\n'
+                   '- [valid , YAML]\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(3, 18, 'trailing-spaces'),
+                   problem2=(6, 7, 'colons'),
+                   problem3=(6, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]  # yamllint disable-line\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(3, 18, 'trailing-spaces'),
+                   problem2=(4, 8, 'colons'),
+                   problem3=(6, 7, 'colons'),
+                   problem4=(6, 26, 'trailing-spaces'))
+
+    def test_disable_line_directive_with_rules(self):
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint disable-line rule:colons\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(4, 18, 'trailing-spaces'),
+                   problem2=(5, 8, 'colons'),
+                   problem3=(7, 7, 'colons'),
+                   problem4=(7, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces  # yamllint disable-line rule:colons  \n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(3, 55, 'trailing-spaces'),
+                   problem2=(4, 8, 'colons'),
+                   problem3=(6, 7, 'colons'),
+                   problem4=(6, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces    \n'
+                   '# yamllint disable-line rule:colons\n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(3, 18, 'trailing-spaces'),
+                   problem2=(7, 7, 'colons'),
+                   problem3=(7, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon  # yamllint disable-line rule:colons\n'
+                   '- [valid , YAML]\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(3, 18, 'trailing-spaces'),
+                   problem2=(6, 7, 'colons'),
+                   problem3=(6, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint disable-line rule:colons\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(3, 18, 'trailing-spaces'),
+                   problem2=(4, 8, 'colons'),
+                   problem3=(7, 26, 'trailing-spaces'))
+        self.check('---\n'
+                   '- [valid , YAML]\n'
+                   '- trailing spaces    \n'
+                   '- bad   : colon\n'
+                   '- [valid , YAML]\n'
+                   '# yamllint disable-line rule:colons rule:trailing-spaces\n'
+                   '- bad  : colon and spaces   \n'
+                   '- [valid , YAML]\n',
+                   self.conf,
+                   problem1=(3, 18, 'trailing-spaces'),
+                   problem2=(4, 8, 'colons'))
+
+    def test_directive_on_last_line(self):
+        conf = 'new-line-at-end-of-file: {}'
+        self.check('---\n'
+                   'no new line',
+                   conf,
+                   problem=(2, 12, 'new-line-at-end-of-file'))
+        self.check('---\n'
+                   '# yamllint disable\n'
+                   'no new line',
+                   conf)
+        self.check('---\n'
+                   'no new line  # yamllint disable',
+                   conf)
+
+    def test_indented_directive(self):
+        conf = 'brackets: {min-spaces-inside: 0, max-spaces-inside: 0}'
+        self.check('---\n'
+                   '- a: 1\n'
+                   '  b:\n'
+                   '    c: [    x]\n',
+                   conf,
+                   problem=(4, 12, 'brackets'))
+        self.check('---\n'
+                   '- a: 1\n'
+                   '  b:\n'
+                   '    # yamllint disable-line rule:brackets\n'
+                   '    c: [    x]\n',
+                   conf)
+
+    def test_directive_on_itself(self):
+        conf = ('comments: {min-spaces-from-content: 2}\n'
+                'comments-indentation: {}\n')
+        self.check('---\n'
+                   '- a: 1 # comment too close\n'
+                   '  b:\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf,
+                   problem1=(2, 8, 'comments'),
+                   problem2=(4, 2, 'comments-indentation'))
+        self.check('---\n'
+                   '# yamllint disable\n'
+                   '- a: 1 # comment too close\n'
+                   '  b:\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf)
+        self.check('---\n'
+                   '- a: 1 # yamllint disable-line\n'
+                   '  b:\n'
+                   '    # yamllint disable-line\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf)
+        self.check('---\n'
+                   '- a: 1 # yamllint disable-line rule:comments\n'
+                   '  b:\n'
+                   '    # yamllint disable-line rule:comments-indentation\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf)
+        self.check('---\n'
+                   '# yamllint disable\n'
+                   '- a: 1 # comment too close\n'
+                   '  # yamllint enable rule:comments-indentation\n'
+                   '  b:\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf,
+                   problem=(6, 2, 'comments-indentation'))

yamllint/__init__.py

@@ -22,7 +22,7 @@ indentation, etc."""
 
 
 APP_NAME = 'yamllint'
-APP_VERSION = '1.1.0'
+APP_VERSION = '1.3.0'
 APP_DESCRIPTION = __doc__
 
 __author__ = u'Adrien Vergé'

yamllint/cli.py

@@ -86,15 +86,24 @@ def run(argv=None):
               'simultaneously.', file=sys.stderr)
         sys.exit(-1)
 
+    # User-global config is supposed to be in ~/.config/yamllint/config
+    if 'XDG_CONFIG_HOME' in os.environ:
+        user_global_config = os.path.join(
+            os.environ['XDG_CONFIG_HOME'], 'yamllint', 'config')
+    else:
+        user_global_config = os.path.expanduser('~/.config/yamllint/config')
+
     try:
         if args.config_data is not None:
-            if ':' not in args.config_data:
+            if args.config_data != '' and ':' not in args.config_data:
                 args.config_data = 'extends: ' + args.config_data
             conf = YamlLintConfig(content=args.config_data)
         elif args.config_file is not None:
             conf = YamlLintConfig(file=args.config_file)
         elif os.path.isfile('.yamllint'):
             conf = YamlLintConfig(file='.yamllint')
+        elif os.path.isfile(user_global_config):
+            conf = YamlLintConfig(file=user_global_config)
         else:
             conf = YamlLintConfig('extends: default')
     except YamlLintConfigError as e:
@@ -123,7 +132,7 @@ def run(argv=None):
             if not first and args.format != 'parsable':
                 print('')
         except EnvironmentError as e:
-            print(e)
+            print(e, file=sys.stderr)
             return_code = -1
 
     sys.exit(return_code)

yamllint/conf/default.yaml

@@ -31,14 +31,14 @@ rules:
   hyphens:
     max-spaces-after: 1
   indentation:
-    spaces: 2
+    spaces: consistent
     indent-sequences: yes
     check-multi-line-strings: no
-  key-duplicates: {}
+  key-duplicates: enable
   line-length:
     max: 80
     allow-non-breakable-words: yes
-  new-line-at-end-of-file: {level: error}
+  new-line-at-end-of-file: enable
   new-lines:
     type: unix
-  trailing-spaces: {}
+  trailing-spaces: enable

yamllint/conf/relaxed.yaml

@@ -15,15 +15,13 @@ rules:
     level: warning
   comments: disable
   comments-indentation: disable
-  document-end: disable
   document-start: disable
   empty-lines:
     level: warning
-  hyphens: disable
+  hyphens:
+    level: warning
   indentation:
-    spaces: consistent
-    indent-sequences: whatever
-    check-multi-line-strings: no
+    level: warning
+    indent-sequences: consistent
   line-length:
     level: warning
-    max: 100

yamllint/config.py

@@ -59,6 +59,9 @@ class YamlLintConfig(object):
         except Exception as e:
             raise YamlLintConfigError('invalid config: %s' % e)
 
+        if type(conf) != dict:
+            raise YamlLintConfigError('invalid config: not a dict')
+
         self.rules = conf.get('rules', {})
 
         # Does this conf override another conf that we need to load?
@@ -83,6 +86,8 @@ class YamlLintConfig(object):
 def validate_rule_conf(rule, conf):
     if conf is False or conf == 'disable':
         return False
+    elif conf == 'enable':
+        conf = {}
 
     if type(conf) == dict:
         if 'level' not in conf:
@@ -117,7 +122,8 @@ def validate_rule_conf(rule, conf):
                     (optkey, rule.ID))
     else:
         raise YamlLintConfigError(('invalid config: rule "%s": should be '
-                                   'either "disable" or a dict') % rule.ID)
+                                   'either "enable", "disable" or a dict')
+                                  % rule.ID)
 
     return conf
 
@@ -126,7 +132,7 @@ def get_extended_config_file(name):
     # Is it a standard conf shipped with yamllint...
     if '/' not in name:
         std_conf = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                'conf', name + '.yml')
+                                'conf', name + '.yaml')
 
         if os.path.isfile(std_conf):
             return std_conf

yamllint/linter.py

@@ -14,6 +14,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import re
+
 import yaml
 
 from yamllint import parser
@@ -56,13 +58,63 @@ def get_costemic_problems(buffer, conf):
 
     # Split token rules from line rules
     token_rules = [r for r in rules if r.TYPE == 'token']
+    comment_rules = [r for r in rules if r.TYPE == 'comment']
     line_rules = [r for r in rules if r.TYPE == 'line']
 
     context = {}
     for rule in token_rules:
         context[rule.ID] = {}
 
-    for elem in parser.token_or_line_generator(buffer):
+    class DisableDirective():
+        def __init__(self):
+            self.rules = set()
+            self.all_rules = set([r.ID for r in rules])
+
+        def process_comment(self, comment):
+            comment = repr(comment)
+
+            if re.match(r'^# yamllint disable( rule:\S+)*\s*$', comment):
+                rules = [item[5:] for item in comment[18:].split(' ')][1:]
+                if len(rules) == 0:
+                    self.rules = self.all_rules.copy()
+                else:
+                    for id in rules:
+                        if id in self.all_rules:
+                            self.rules.add(id)
+
+            elif re.match(r'^# yamllint enable( rule:\S+)*\s*$', comment):
+                rules = [item[5:] for item in comment[17:].split(' ')][1:]
+                if len(rules) == 0:
+                    self.rules.clear()
+                else:
+                    for id in rules:
+                        self.rules.discard(id)
+
+        def is_disabled_by_directive(self, problem):
+            return problem.rule in self.rules
+
+    class DisableLineDirective(DisableDirective):
+        def process_comment(self, comment):
+            comment = repr(comment)
+
+            if re.match(r'^# yamllint disable-line( rule:\S+)*\s*$', comment):
+                rules = [item[5:] for item in comment[23:].split(' ')][1:]
+                if len(rules) == 0:
+                    self.rules = self.all_rules.copy()
+                else:
+                    for id in rules:
+                        if id in self.all_rules:
+                            self.rules.add(id)
+
+    # Use a cache to store problems and flush it only when a end of line is
+    # found. This allows the use of yamllint directive to disable some rules on
+    # some lines.
+    cache = []
+    disabled = DisableDirective()
+    disabled_for_line = DisableLineDirective()
+    disabled_for_next_line = DisableLineDirective()
+
+    for elem in parser.token_or_comment_or_line_generator(buffer):
         if isinstance(elem, parser.Token):
             for rule in token_rules:
                 rule_conf = conf.rules[rule.ID]
@@ -72,15 +124,39 @@ def get_costemic_problems(buffer, conf):
                                           context[rule.ID]):
                     problem.rule = rule.ID
                     problem.level = rule_conf['level']
-                    yield problem
+                    cache.append(problem)
+        elif isinstance(elem, parser.Comment):
+            for rule in comment_rules:
+                rule_conf = conf.rules[rule.ID]
+                for problem in rule.check(rule_conf, elem):
+                    problem.rule = rule.ID
+                    problem.level = rule_conf['level']
+                    cache.append(problem)
+
+            disabled.process_comment(elem)
+            if elem.is_inline():
+                disabled_for_line.process_comment(elem)
+            else:
+                disabled_for_next_line.process_comment(elem)
         elif isinstance(elem, parser.Line):
             for rule in line_rules:
                 rule_conf = conf.rules[rule.ID]
                 for problem in rule.check(rule_conf, elem):
                     problem.rule = rule.ID
                     problem.level = rule_conf['level']
+                    cache.append(problem)
+
+            # This is the last token/comment/line of this line, let's flush the
+            # problems found (but filter them according to the directives)
+            for problem in cache:
+                if not (disabled_for_line.is_disabled_by_directive(problem) or
+                        disabled.is_disabled_by_directive(problem)):
                     yield problem
 
+            disabled_for_line = disabled_for_next_line
+            disabled_for_next_line = DisableLineDirective()
+            cache = []
+
 
 def get_syntax_error(buffer):
     try:
@@ -94,6 +170,9 @@ def get_syntax_error(buffer):
 
 
 def _run(buffer, conf):
+    assert hasattr(buffer, '__getitem__'), \
+        '_run() argument must be a buffer, not a stream'
+
     # If the document contains a syntax error, save it and yield it at the
     # right line
     syntax_error = get_syntax_error(buffer)

yamllint/parser.py

@@ -38,6 +38,40 @@ class Token(object):
         self.nextnext = nextnext
 
 
+class Comment(object):
+    def __init__(self, line_no, column_no, buffer, pointer,
+                 token_before=None, token_after=None, comment_before=None):
+        self.line_no = line_no
+        self.column_no = column_no
+        self.buffer = buffer
+        self.pointer = pointer
+        self.token_before = token_before
+        self.token_after = token_after
+        self.comment_before = comment_before
+
+    def __repr__(self):
+        end = self.buffer.find('\n', self.pointer)
+        if end == -1:
+            end = self.buffer.find('\0', self.pointer)
+        if end != -1:
+            return self.buffer[self.pointer:end]
+        return self.buffer[self.pointer:]
+
+    def __eq__(self, other):
+        return (isinstance(other, Comment) and
+                self.line_no == other.line_no and
+                self.column_no == other.column_no and
+                str(self) == str(other))
+
+    def is_inline(self):
+        return (
+            not isinstance(self.token_before, yaml.StreamStartToken) and
+            self.line_no == self.token_before.end_mark.line + 1 and
+            # sometimes token end marks are on the next line
+            self.buffer[self.token_before.end_mark.pointer - 1] != '\n'
+        )
+
+
 def line_generator(buffer):
     line_no = 1
     cur = 0
@@ -51,7 +85,39 @@ def line_generator(buffer):
     yield Line(line_no, buffer, start=cur, end=len(buffer))
 
 
-def token_generator(buffer):
+def comments_between_tokens(token1, token2):
+    """Find all comments between two tokens"""
+    if token2 is None:
+        buf = token1.end_mark.buffer[token1.end_mark.pointer:]
+    elif (token1.end_mark.line == token2.start_mark.line and
+          not isinstance(token1, yaml.StreamStartToken) and
+          not isinstance(token2, yaml.StreamEndToken)):
+        return
+    else:
+        buf = token1.end_mark.buffer[token1.end_mark.pointer:
+                                     token2.start_mark.pointer]
+
+    line_no = token1.end_mark.line + 1
+    column_no = token1.end_mark.column + 1
+    pointer = token1.end_mark.pointer
+
+    comment_before = None
+    for line in buf.split('\n'):
+        pos = line.find('#')
+        if pos != -1:
+            comment = Comment(line_no, column_no + pos,
+                              token1.end_mark.buffer, pointer + pos,
+                              token1, token2, comment_before)
+            yield comment
+
+            comment_before = comment
+
+        pointer += len(line) + 1
+        line_no += 1
+        column_no = 1
+
+
+def token_or_comment_generator(buffer):
     yaml_loader = yaml.BaseLoader(buffer)
 
     try:
@@ -63,6 +129,9 @@ def token_generator(buffer):
 
             yield Token(curr.start_mark.line + 1, curr, prev, next, nextnext)
 
+            for comment in comments_between_tokens(curr, next):
+                yield comment
+
             prev = curr
             curr = next
 
@@ -70,19 +139,19 @@ def token_generator(buffer):
         pass
 
 
-def token_or_line_generator(buffer):
+def token_or_comment_or_line_generator(buffer):
     """Generator that mixes tokens and lines, ordering them by line number"""
-    token_gen = token_generator(buffer)
+    tok_or_com_gen = token_or_comment_generator(buffer)
     line_gen = line_generator(buffer)
 
-    token = next(token_gen, None)
+    tok_or_com = next(tok_or_com_gen, None)
     line = next(line_gen, None)
 
-    while token is not None or line is not None:
-        if token is None or (line is not None and
-                             token.line_no > line.line_no):
+    while tok_or_com is not None or line is not None:
+        if tok_or_com is None or (line is not None and
+                                  tok_or_com.line_no > line.line_no):
             yield line
             line = next(line_gen, None)
         else:
-            yield token
-            token = next(token_gen, None)
+            yield tok_or_com
+            tok_or_com = next(tok_or_com_gen, None)

yamllint/rules/comments.py

@@ -55,33 +55,25 @@ Use this rule to control the position and formatting of comments.
 """
 
 
-import yaml
-
 from yamllint.linter import LintProblem
-from yamllint.rules.common import get_comments_between_tokens
 
 
 ID = 'comments'
-TYPE = 'token'
+TYPE = 'comment'
 CONF = {'require-starting-space': bool,
         'min-spaces-from-content': int}
 
 
-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
-                comment.line == token.end_mark.line + 1):
-            # Sometimes token end marks are on the next line
-            if token.end_mark.buffer[token.end_mark.pointer - 1] != '\n':
-                if (comment.pointer - token.end_mark.pointer <
-                        conf['min-spaces-from-content']):
-                    yield LintProblem(comment.line, comment.column,
-                                      'too few spaces before comment')
+def check(conf, comment):
+    if (conf['min-spaces-from-content'] != -1 and comment.is_inline() and
+            comment.pointer - comment.token_before.end_mark.pointer <
+            conf['min-spaces-from-content']):
+        yield LintProblem(comment.line_no, comment.column_no,
+                          'too few spaces before comment')
 
-        if (conf['require-starting-space'] and
-                comment.pointer + 1 < len(comment.buffer) and
-                comment.buffer[comment.pointer + 1] != ' ' and
-                comment.buffer[comment.pointer + 1] != '\n'):
-            yield LintProblem(comment.line, comment.column + 1,
-                              'missing starting space in comment')
+    if (conf['require-starting-space'] and
+            comment.pointer + 1 < len(comment.buffer) and
+            comment.buffer[comment.pointer + 1] != ' ' and
+            comment.buffer[comment.pointer + 1] != '\n'):
+        yield LintProblem(comment.line_no, comment.column_no + 1,
+                          'missing starting space in comment')

yamllint/rules/comments_indentation.py

@@ -78,11 +78,11 @@ Use this rule to force comments to be indented like content.
 import yaml
 
 from yamllint.linter import LintProblem
-from yamllint.rules.common import get_line_indent, get_comments_between_tokens
+from yamllint.rules.common import get_line_indent
 
 
 ID = 'comments-indentation'
-TYPE = 'token'
+TYPE = 'comment'
 
 
 # Case A:
@@ -98,28 +98,42 @@ TYPE = 'token'
 #     # commented line 2
 #     current: line
 
-def check(conf, token, prev, next, nextnext, context):
-    if prev is None:
+def check(conf, comment):
+    # Only check block comments
+    if (not isinstance(comment.token_before, yaml.StreamStartToken) and
+            comment.token_before.end_mark.line + 1 == comment.line_no):
         return
 
-    curr_line_indent = token.start_mark.column
-    if isinstance(token, yaml.StreamEndToken):
-        curr_line_indent = 0
+    next_line_indent = comment.token_after.start_mark.column
+    if isinstance(comment.token_after, yaml.StreamEndToken):
+        next_line_indent = 0
 
-    skip_first_line = True
-    if isinstance(prev, yaml.StreamStartToken):
-        skip_first_line = False
+    if isinstance(comment.token_before, yaml.StreamStartToken):
         prev_line_indent = 0
     else:
-        prev_line_indent = get_line_indent(prev)
+        prev_line_indent = get_line_indent(comment.token_before)
 
-    if prev_line_indent <= curr_line_indent:
-        prev_line_indent = -1  # disable it
+    # In the following case only the next line indent is valid:
+    #     list:
+    #         # comment
+    #         - 1
+    #         - 2
+    if prev_line_indent <= next_line_indent:
+        prev_line_indent = next_line_indent
 
-    for comment in get_comments_between_tokens(
-            prev, token, skip_first_line=skip_first_line):
-        if comment.column - 1 == curr_line_indent:
-            prev_line_indent = -1  # disable it
-        elif comment.column - 1 != prev_line_indent:
-            yield LintProblem(comment.line, comment.column,
-                              'comment not indented like content')
+    # If two indents are valid but a previous comment went back to normal
+    # indent, for the next ones to do the same. In other words, avoid this:
+    #     list:
+    #         - 1
+    #     # comment on valid indent (0)
+    #         # comment on valid indent (4)
+    #     other-list:
+    #         - 2
+    if (comment.comment_before is not None and
+            not comment.comment_before.is_inline()):
+        prev_line_indent = comment.comment_before.column_no - 1
+
+    if (comment.column_no - 1 != prev_line_indent and
+            comment.column_no - 1 != next_line_indent):
+        yield LintProblem(comment.line_no, comment.column_no,
+                          'comment not indented like content')

yamllint/rules/common.py

@@ -48,27 +48,6 @@ def spaces_before(token, prev, next, min=-1, max=-1,
                                token.start_mark.column + 1, min_desc)
 
 
-class Comment(object):
-    def __init__(self, line, column, buffer, pointer):
-        self.line = line
-        self.column = column
-        self.buffer = buffer
-        self.pointer = pointer
-
-    def __repr__(self):
-        end = self.buffer.find('\n', self.pointer)
-        if end == -1:
-            end = self.buffer.find('\0', self.pointer)
-        if end != -1:
-            return self.buffer[self.pointer:end]
-        return self.buffer[self.pointer:]
-
-    def __eq__(self, other):
-        return (self.line == other.line and
-                self.column == other.column and
-                str(self) == str(other))
-
-
 def get_line_indent(token):
     """Finds the indent of the line the token starts in."""
     start = token.start_mark.buffer.rfind('\n', 0,
@@ -98,35 +77,6 @@ def get_real_end_line(token):
     return end_line
 
 
-def get_comments_between_tokens(token1, token2, skip_first_line=False):
-    if token2 is None:
-        buf = token1.end_mark.buffer[token1.end_mark.pointer:]
-    elif (token1.end_mark.line == token2.start_mark.line and
-          not isinstance(token1, yaml.StreamStartToken) and
-          not isinstance(token2, yaml.StreamEndToken)):
-        return
-    else:
-        buf = token1.end_mark.buffer[token1.end_mark.pointer:
-                                     token2.start_mark.pointer]
-
-    line_no = token1.end_mark.line + 1
-    column_no = token1.end_mark.column + 1
-    pointer = token1.end_mark.pointer
-
-    for line in buf.split('\n'):
-        if skip_first_line:
-            skip_first_line = False
-        else:
-            pos = line.find('#')
-            if pos != -1:
-                yield Comment(line_no, column_no + pos,
-                              token1.end_mark.buffer, pointer + pos)
-
-        pointer += len(line) + 1
-        line_no += 1
-        column_no = 1
-
-
 def is_explicit_key(token):
     # explicit key:
     #   ? key

yamllint/rules/empty_lines.py

@@ -62,7 +62,7 @@ CONF = {'max': int,
 
 def check(conf, line):
     if line.start == line.end and line.end < len(line.buffer):
-        # Only alert on the last blank line of a serie
+        # Only alert on the last blank line of a series
         if (line.end < len(line.buffer) - 1 and
                 line.buffer[line.end + 1] == '\n'):
             return

yamllint/rules/indentation.py

@@ -26,8 +26,9 @@ Use this rule to control the indentation.
 * ``indent-sequences`` defines whether block sequences should be indented or
   not (when in a mapping, this indentation is not mandatory -- some people
   perceive the ``-`` as part of the indentation). Possible values: ``yes``,
-  ``no`` and ``whatever`` (the latter means either indenting or not indenting
-  block sequences is OK.
+  ``no``, ``whatever`` and ``consistent``. ``consistent`` requires either all
+  block sequences to be indented, or none to be. ``whatever`` means either
+  indenting or not indenting individual block sequences is OK.
 * ``check-multi-line-strings`` defines whether to lint indentation in
   multi-line strings. Set to ``yes`` to enable, ``no`` to disable.
 
@@ -129,6 +130,28 @@ Use this rule to control the indentation.
         - spaghetti
         - sauce
 
+#. With ``indentation: {spaces: 2, indent-sequences: consistent}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    - flying:
+      - spaghetti
+      - monster
+    - not flying:
+      - spaghetti
+      - sauce
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - flying:
+        - spaghetti
+        - monster
+    - not flying:
+      - spaghetti
+      - sauce
+
 #. With ``indentation: {spaces: 4, check-multi-line-strings: yes}``
 
    the following code snippet would **PASS**:
@@ -176,7 +199,7 @@ from yamllint.rules.common import is_explicit_key, get_real_end_line
 ID = 'indentation'
 TYPE = 'token'
 CONF = {'spaces': (int, 'consistent'),
-        'indent-sequences': (True, False, 'whatever'),
+        'indent-sequences': (bool, 'whatever', 'consistent'),
         'check-multi-line-strings': bool}
 
 ROOT, B_MAP, F_MAP, B_SEQ, F_SEQ, B_ENT, KEY, VAL = range(8)
@@ -210,7 +233,7 @@ def check_scalar_indentation(conf, token, context):
         elif token.style in ('"', "'"):
             return token.start_mark.column + 1
         elif token.style in ('>', '|'):
-            if context['stack'][-1].type == B_SEQ:
+            if context['stack'][-1].type == B_ENT:
                 # - >
                 #     multi
                 #     line
@@ -272,11 +295,12 @@ def check_scalar_indentation(conf, token, context):
                               (expected_indent, indent))
 
 
-def check(conf, token, prev, next, nextnext, context):
+def _check(conf, token, prev, next, nextnext, context):
     if 'stack' not in context:
         context['stack'] = [Parent(ROOT, 0)]
         context['cur_line'] = -1
         context['spaces'] = conf['spaces']
+        context['indent-sequences'] = conf['indent-sequences']
 
     # Step 1: Lint
 
@@ -287,11 +311,10 @@ def check(conf, token, prev, next, nextnext, context):
     first_in_line = (is_visible and
                      token.start_mark.line + 1 > context['cur_line'])
 
-    def detect_indent(next):
+    def detect_indent(base_indent, next):
         if type(context['spaces']) is not int:
-            context['spaces'] = (next.start_mark.column -
-                                 context['stack'][-1].indent)
-        return context['spaces']
+            context['spaces'] = next.start_mark.column - base_indent
+        return base_indent + context['spaces']
 
     if first_in_line:
         found_indentation = token.start_mark.column
@@ -303,7 +326,7 @@ def check(conf, token, prev, next, nextnext, context):
         elif (context['stack'][-1].type == KEY and
                 context['stack'][-1].explicit_key and
                 not isinstance(token, yaml.ValueToken)):
-            expected += detect_indent(token)
+            expected = detect_indent(expected, token)
 
         if found_indentation != expected:
             yield LintProblem(token.start_mark.line + 1, found_indentation + 1,
@@ -325,19 +348,18 @@ def check(conf, token, prev, next, nextnext, context):
     # Step 2.b: Update state
 
     if isinstance(token, yaml.BlockMappingStartToken):
+        #   - a: 1
+        # or
+        #   - ? a
+        #     : 1
+        # or
+        #   - ?
+        #       a
+        #     : 1
         assert isinstance(next, yaml.KeyToken)
-        if next.start_mark.line == token.start_mark.line:
-            #   - a: 1
-            #     b: 2
-            # or
-            #   - ? a
-            #     : 1
-            indent = token.start_mark.column
-        else:
-            #   - ?
-            #       a
-            #     : 1
-            indent = token.start_mark.column + detect_indent(next)
+        assert next.start_mark.line == token.start_mark.line
+
+        indent = token.start_mark.column
 
         context['stack'].append(Parent(B_MAP, indent))
 
@@ -349,7 +371,7 @@ def check(conf, token, prev, next, nextnext, context):
             #   - {
             #     a: 1, b: 2
             #   }
-            indent = context['cur_line_indent'] + detect_indent(next)
+            indent = detect_indent(context['cur_line_indent'], next)
 
         context['stack'].append(Parent(F_MAP, indent,
                                        line_indent=context['cur_line_indent']))
@@ -357,8 +379,8 @@ def check(conf, token, prev, next, nextnext, context):
     elif isinstance(token, yaml.BlockSequenceStartToken):
         #   - - a
         #     - b
-        assert next.start_mark.line == token.start_mark.line
         assert isinstance(next, yaml.BlockEntryToken)
+        assert next.start_mark.line == token.start_mark.line
 
         indent = token.start_mark.column
 
@@ -383,7 +405,7 @@ def check(conf, token, prev, next, nextnext, context):
             #   -
             #     key:
             #       value
-            indent = token.start_mark.column + detect_indent(next)
+            indent = detect_indent(token.start_mark.column, next)
 
         context['stack'].append(Parent(B_ENT, indent))
 
@@ -395,7 +417,7 @@ def check(conf, token, prev, next, nextnext, context):
             #   - [
             #   a, b
             # ]
-            indent = context['cur_line_indent'] + detect_indent(next)
+            indent = detect_indent(context['cur_line_indent'], next)
 
         context['stack'].append(Parent(F_SEQ, indent,
                                        line_indent=context['cur_line_indent']))
@@ -433,7 +455,7 @@ def check(conf, token, prev, next, nextnext, context):
                 #   ? k
                 #   :
                 #     value
-                indent = context['stack'][-1].indent + detect_indent(next)
+                indent = detect_indent(context['stack'][-1].indent, next)
             elif next.start_mark.line == prev.start_mark.line:
                 #   k: value
                 indent = next.start_mark.column
@@ -444,38 +466,46 @@ def check(conf, token, prev, next, nextnext, context):
                 # yaml.scan()ning this:
                 #     '- lib:\n'
                 #     '  - var\n'
-                if conf['indent-sequences'] is False:
+                if context['indent-sequences'] is False:
                     indent = context['stack'][-1].indent
-                elif conf['indent-sequences'] is True:
-                    indent = context['stack'][-1].indent + detect_indent(next)
-                else:  # 'whatever'
+                elif context['indent-sequences'] is True:
+                    indent = detect_indent(context['stack'][-1].indent, next)
+                else:  # 'whatever' or 'consistent'
                     if next.start_mark.column == context['stack'][-1].indent:
                         #   key:
                         #   - e1
                         #   - e2
+                        if context['indent-sequences'] == 'consistent':
+                            context['indent-sequences'] = False
                         indent = context['stack'][-1].indent
                     else:
+                        if context['indent-sequences'] == 'consistent':
+                            context['indent-sequences'] = True
                         #   key:
                         #     - e1
                         #     - e2
-                        indent = (context['stack'][-1].indent +
-                                  detect_indent(next))
+                        indent = detect_indent(context['stack'][-1].indent,
+                                               next)
             else:
                 #   k:
                 #     value
-                indent = context['stack'][-1].indent + detect_indent(next)
+                indent = detect_indent(context['stack'][-1].indent, next)
 
             context['stack'].append(Parent(VAL, indent))
 
     consumed_current_token = False
     while True:
         if (context['stack'][-1].type == F_SEQ and
-                isinstance(token, yaml.FlowSequenceEndToken)):
+                isinstance(token, yaml.FlowSequenceEndToken) and
+                not consumed_current_token):
             context['stack'].pop()
+            consumed_current_token = True
 
         elif (context['stack'][-1].type == F_MAP and
-                isinstance(token, yaml.FlowMappingEndToken)):
+                isinstance(token, yaml.FlowMappingEndToken) and
+                not consumed_current_token):
             context['stack'].pop()
+            consumed_current_token = True
 
         elif (context['stack'][-1].type in (B_MAP, B_SEQ) and
                 isinstance(token, yaml.BlockEndToken) and
@@ -514,3 +544,13 @@ def check(conf, token, prev, next, nextnext, context):
 
         else:
             break
+
+
+def check(conf, token, prev, next, nextnext, context):
+    try:
+        for problem in _check(conf, token, prev, next, nextnext, context):
+            yield problem
+    except AssertionError:
+        yield LintProblem(token.start_mark.line + 1,
+                          token.start_mark.column + 1,
+                          'cannot infer indentation: unexpected token')

yamllint/rules/line_length.py

@@ -59,7 +59,7 @@ Use this rule to set a limit to lines length.
    the following code snippet would **FAIL**:
    ::
 
-    - this line is waaaaaaaaaaaaaay too long but could be easily splitted...
+    - this line is waaaaaaaaaaaaaay too long but could be easily split...
 
 #. With ``line-length: {max: 60, allow-non-breakable-words: no}``
 
@@ -90,7 +90,7 @@ def check(conf, line):
                 start += 1
 
             if start != line.end:
-                if line.buffer[start] == '#':
+                if line.buffer[start] in ('#', '-'):
                     start += 2
 
                 if line.buffer.find(' ', start, line.end) == -1: