yamllint version 1.2.2

Patch allow-non-breakable-words on '-'

.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

MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include README.rst
+include docs/*

README.rst

@@ -38,6 +38,27 @@ Screenshot
 Installation
 ^^^^^^^^^^^^
 
+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
@@ -57,10 +78,29 @@ Usage
 
 .. code:: bash
 
+ # Use a pre-defined lint configuration
+ 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
+^^^^^^^^^^^^^^^^^^^^^
+
+.. code:: yaml
+
+ extends: default
+
+ rules:
+   # 80 chars should be enough, but don't fail if a line is longer
+   line-length:
+     max: 80
+     level: warning
+
+   # don't bother me with this rule
+   indentation: disable

docs/conf.py

@@ -38,6 +38,5 @@ htmlhelp_basename = 'yamllintdoc'
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'yamllint', u'yamllint Documentation',
+    ('index', 'yamllint', '', [u'Adrien Vergé'], 1)
-     [u'Adrien Vergé'], 1)
 ]

docs/configuration.rst

@@ -1,27 +1,44 @@
 Configuration
 =============
 
-yamllint uses a set of *rules* to check sources files for problems. Each rule is
+yamllint uses a set of :doc:`rules <rules>` to check source files for problems.
-independent from the others, and can be enabled, disabled or tweaked. All these
+Each rule is independent from the others, and can be enabled, disabled or
-settings can be gathered in a configuration file.
+tweaked. All these settings can be gathered in a configuration file.
 
-To use a custom configuration file, either name it ``.yamllint`` in your working
+To use a custom configuration file, use the ``-c`` option:
-directory, or 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``
+- ``$HOME/.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>`.
 
+There is another pre-defined configuration named ``relaxed``. As its name
+suggests, it is more tolerant.
+
+It can be chosen using:
+
+.. code:: bash
+
+ yamllint -d relaxed file.yml
+
 Extending the default configuration
 -----------------------------------
 
@@ -50,7 +67,7 @@ strict on block sequences indentation:
  extends: default
 
  rules:
-   # 80 should be enough, but don't fail if a line is longer
+   # 80 chars should be enough, but don't fail if a line is longer
    line-length:
      max: 80
      level: warning
@@ -63,6 +80,21 @@ strict on block sequences indentation:
    indentation:
      indent-sequences: whatever
 
+Custom configuration without a config file
+------------------------------------------
+
+It is possible -- although not recommended -- to pass custom configuration
+options to yamllint with the ``-d`` (short for ``--config-data``) option.
+
+Its content can either be the name of a pre-defined conf (example: ``default``
+or ``relaxed``) or a serialized YAML object describing the configuration.
+
+For instance:
+
+.. code:: bash
+
+ yamllint -d "{extends: relaxed, rules: {line-length: {max: 120}}}" file.yaml
+
 Errors and warnings
 -------------------
 

docs/quickstart.rst

@@ -4,16 +4,34 @@ Quickstart
 Installing yamllint
 -------------------
 
-First, install yamllint. The easiest way is to use pip, the Python package
+On Fedora / CentOS:
-manager:
 
-::
+.. 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``:
+installed, yamllint is supported by default. It is automatically enabled when
-
+editing YAML files.
-::
-
- 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
 
 Other text editors
 ------------------

setup.py

@@ -30,7 +30,7 @@ setup(
     keywords=['yaml', 'lint', 'linter', 'syntax', 'checker'],
     url='https://github.com/adrienverge/yamllint',
     classifiers=[
-        'Development Status :: 4 - Beta',
+        'Development Status :: 5 - Production/Stable',
         'Environment :: Console',
         'Intended Audience :: Developers',
         'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
@@ -44,7 +44,8 @@ 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'],
     test_suite='nose.collector',

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)
@@ -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'

tests/rules/test_indentation.py

@@ -381,6 +381,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'
@@ -496,6 +631,87 @@ class IndentationTestCase(RuleTestCase):
                    '        date: 1991\n'
                    '...\n', conf)
 
+    def test_consistent(self):
+        conf = ('indentation: {spaces: consistent,\n'
+                '              indent-sequences: whatever}\n'
+                'document-start: disable\n')
+        self.check('---\n'
+                   'object:\n'
+                   ' k1:\n'
+                   '  - a\n'
+                   '  - b\n'
+                   ' k2: v2\n'
+                   ' k3:\n'
+                   '  - name: Unix\n'
+                   '    date: 1969\n'
+                   '  - name: Linux\n'
+                   '    date: 1991\n'
+                   '...\n', conf)
+        self.check('---\n'
+                   'object:\n'
+                   '  k1:\n'
+                   '  - a\n'
+                   '  - b\n'
+                   '  k2: v2\n'
+                   '  k3:\n'
+                   '  - name: Unix\n'
+                   '    date: 1969\n'
+                   '  - name: Linux\n'
+                   '    date: 1991\n'
+                   '...\n', conf)
+        self.check('---\n'
+                   'object:\n'
+                   '   k1:\n'
+                   '      - a\n'
+                   '      - b\n'
+                   '   k2: v2\n'
+                   '   k3:\n'
+                   '      - name: Unix\n'
+                   '        date: 1969\n'
+                   '      - name: Linux\n'
+                   '        date: 1991\n'
+                   '...\n', conf)
+        self.check('first is not indented:\n'
+                   '  value is indented\n', conf)
+        self.check('first is not indented:\n'
+                   '     value:\n'
+                   '          is indented\n', conf)
+        self.check('- first is already indented:\n'
+                   '    value is indented too\n', conf)
+        self.check('- first is already indented:\n'
+                   '       value:\n'
+                   '            is indented too\n', conf)
+        self.check('- first is already indented:\n'
+                   '       value:\n'
+                   '             is indented too\n', conf, problem=(3, 14))
+        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)
+        self.check('---\n'
+                   'list one:\n'
+                   ' - 1\n'
+                   ' - 2\n'
+                   ' - 3\n'
+                   'list two:\n'
+                   '- a\n'
+                   '- b\n'
+                   '- c\n', conf)
+
     def test_indent_sequences_whatever(self):
         conf = 'indentation: {spaces: 4, indent-sequences: whatever}'
         self.check('---\n'
@@ -534,10 +750,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'
@@ -589,7 +855,7 @@ class IndentationTestCase(RuleTestCase):
         # flow: [
         #   ...
         # ]
-        conf = 'indentation: {spaces: 2}'
+        conf = 'indentation: {spaces: consistent}'
         self.check('---\n'
                    'a: {\n'
                    '  x: 1,\n'
@@ -603,7 +869,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'
@@ -622,7 +888,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'
@@ -671,13 +937,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'
@@ -727,7 +1004,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'
@@ -762,7 +1039,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'
@@ -778,7 +1055,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'
@@ -796,7 +1073,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'
@@ -812,7 +1089,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'
@@ -852,7 +1129,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'
@@ -871,7 +1148,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'
@@ -926,7 +1203,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'
@@ -950,18 +1227,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'
@@ -969,12 +1280,11 @@ class IndentationTestCase(RuleTestCase):
                    '       value\n'
                    '...\n', conf, problem=(5, 8))
         self.check('---\n'
-                   'object:\n'
+                   '- - ?\n'
-                   '    ?\n'
+                   '       key\n'
-                   '        key\n'
                    '    :\n'
-                   '        value\n'
+                   '      value\n'
-                   '...\n', conf)
+                   '...\n', conf, problem=(5, 7))
         self.check('---\n'
                    'object:\n'
                    '    ?\n'
@@ -991,7 +1301,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'
@@ -1006,6 +1316,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'
@@ -1027,16 +1366,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'
@@ -1096,7 +1428,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'
@@ -1105,7 +1437,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'
@@ -1124,12 +1456,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)
@@ -1157,7 +1532,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))
@@ -1179,7 +1555,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)
@@ -1209,7 +1586,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))
@@ -1264,7 +1642,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'
@@ -1301,7 +1680,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'
@@ -1341,7 +1721,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'
@@ -1378,7 +1759,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'
@@ -1421,7 +1803,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'
@@ -1442,7 +1825,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'
@@ -1469,7 +1853,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'
@@ -1496,7 +1881,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'
@@ -1513,7 +1899,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'
@@ -1528,3 +1915,39 @@ class ScalarIndentationTestCase(RuleTestCase):
                    '      paragraph gap, \\n and\n'
                    '       spaces.\n', conf,
                    problem1=(3, 6), problem2=(5, 7), problem3=(6, 8))
+
+    def test_consistent(self):
+        conf = ('indentation: {spaces: consistent,\n'
+                '              check-multi-line-strings: yes}\n'
+                'document-start: disable\n')
+        self.check('multi\n'
+                   'line\n', conf)
+        self.check('multi\n'
+                   ' line\n', conf, problem=(2, 2))
+        self.check('- multi\n'
+                   '  line\n', conf)
+        self.check('- multi\n'
+                   '   line\n', conf, problem=(2, 4))
+        self.check('a key: multi\n'
+                   '  line\n', conf, problem=(2, 3))
+        self.check('a key: multi\n'
+                   '        line\n', conf, problem=(2, 9))
+        self.check('a key:\n'
+                   '  multi\n'
+                   '   line\n', conf, problem=(3, 4))
+        self.check('- C code: void main() {\n'
+                   '              printf("foo");\n'
+                   '          }\n', conf, problem=(2, 15))
+        self.check('- C code:\n'
+                   '    void main() {\n'
+                   '        printf("foo");\n'
+                   '    }\n', conf, problem=(3, 9))
+        self.check('>\n'
+                   '  multi\n'
+                   '  line\n', conf)
+        self.check('>\n'
+                   '     multi\n'
+                   '     line\n', conf)
+        self.check('>\n'
+                   '     multi\n'
+                   '      line\n', conf, problem=(3, 7))

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(
@@ -58,6 +62,58 @@ class SimpleConfigTestCase(unittest.TestCase):
                                   '    max-spaces-after: 1\n'
                                   '    abcdef: yes\n')
 
+    def test_validate_rule_conf(self):
+        class Rule(object):
+            ID = 'fake'
+
+        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,
+                          config.validate_rule_conf, Rule, {'level': 'warn'})
+
+        Rule.CONF = {'length': int}
+        config.validate_rule_conf(Rule, {'length': 8})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'height': 8})
+
+        Rule.CONF = {'a': bool, 'b': int}
+        config.validate_rule_conf(Rule, {'a': True, 'b': 0})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'a': True})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'b': 0})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'a': 1, 'b': 0})
+
+        Rule.CONF = {'choice': (True, 88, 'str')}
+        config.validate_rule_conf(Rule, {'choice': True})
+        config.validate_rule_conf(Rule, {'choice': 88})
+        config.validate_rule_conf(Rule, {'choice': 'str'})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'choice': False})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'choice': 99})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'choice': 'abc'})
+
+        Rule.CONF = {'choice': (int, 'hardcoded')}
+        config.validate_rule_conf(Rule, {'choice': 42})
+        config.validate_rule_conf(Rule, {'choice': 'hardcoded'})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'choice': False})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'choice': 'abc'})
+
 
 class ExtendedConfigTestCase(unittest.TestCase):
     def test_extend_add_rule(self):

tests/test_linter.py

@@ -0,0 +1,46 @@
+# -*- 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/>.
+
+import io
+
+import unittest
+
+from yamllint.config import YamlLintConfig
+from yamllint import linter
+
+
+class LinterTestCase(unittest.TestCase):
+    def fake_config(self):
+        return YamlLintConfig('extends: default')
+
+    def test_run_on_string(self):
+        linter.run('test: document', self.fake_config())
+
+    def test_run_on_bytes(self):
+        linter.run(b'test: document', self.fake_config())
+
+    def test_run_on_unicode(self):
+        linter.run(u'test: document', self.fake_config())
+
+    def test_run_on_stream(self):
+        linter.run(io.StringIO(u'hello'), self.fake_config())
+
+    def test_run_on_int(self):
+        self.assertRaises(TypeError, linter.run, 42, self.fake_config())
+
+    def test_run_on_list(self):
+        self.assertRaises(TypeError, linter.run,
+                          ['h', 'e', 'l', 'l', 'o'], self.fake_config())

tests/test_spec_examples.py

@@ -14,6 +14,7 @@
 # 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 io import open
 import os
 
 from tests.common import RuleTestCase
@@ -120,7 +121,8 @@ conf_overrides = {
     'example-10.2': ('indentation: {indent-sequences: no}\n'),
 }
 
-files = os.listdir('tests/yaml-1.2-spec-examples')
+files = os.listdir(os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                                'yaml-1.2-spec-examples'))
 assert len(files) == 132
 
 
@@ -178,7 +180,7 @@ for file in files:
     if file in pyyaml_blacklist:
         continue
 
-    with open('tests/yaml-1.2-spec-examples/' + file) as f:
+    with open('tests/yaml-1.2-spec-examples/' + file, encoding='utf-8') as f:
         conf = conf_general + conf_overrides.get(file, '')
         setattr(SpecificationTestCase, 'test_' + file,
                 _gen_test(f.read(), conf))

yamllint/__init__.py

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

yamllint/cli.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
@@ -67,8 +66,11 @@ def run(argv=None):
                                      description=APP_DESCRIPTION)
     parser.add_argument('files', metavar='FILE_OR_DIR', nargs='+',
                         help='files to check')
-    parser.add_argument('-c', '--config', dest='config_file', action='store',
+    parser.add_argument('-c', '--config-file', dest='config_file',
-                        help='path to a custom configuration')
+                        action='store', help='path to a custom configuration')
+    parser.add_argument('-d', '--config-data', dest='config_data',
+                        action='store',
+                        help='custom configuration (as YAML source)')
     parser.add_argument('-f', '--format',
                         choices=('parsable', 'standard'), default='standard',
                         help='format for parsing output')
@@ -79,11 +81,31 @@ def run(argv=None):
 
     args = parser.parse_args(argv)
 
+    if args.config_file is not None and args.config_data is not None:
+        print('Options --config-file and --config-data cannot be used '
+              'simultaneously.', file=sys.stderr)
+        sys.exit(-1)
+
+    # User-global config is supposed to be in ~/.config/yamllint/config
+    user_global_config = None
+    if 'XDG_CONFIG_HOME' in os.environ:
+        user_global_config = os.path.join(
+            os.environ['XDG_CONFIG_HOME'], 'yamllint', 'config')
+    elif 'HOME' in os.environ:
+        user_global_config = os.path.join(
+            os.environ['HOME'], '.config', 'yamllint', 'config')
+
     try:
-        if args.config_file is not None:
+        if args.config_data is not None:
+            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 user_global_config and os.path.isfile(user_global_config):
+            conf = YamlLintConfig(file=user_global_config)
         else:
             conf = YamlLintConfig('extends: default')
     except YamlLintConfigError as e:
@@ -112,7 +134,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

@@ -0,0 +1,27 @@
+---
+
+extends: default
+
+rules:
+  braces:
+    level: warning
+    max-spaces-inside: 1
+  brackets:
+    level: warning
+    max-spaces-inside: 1
+  colons:
+    level: warning
+  commas:
+    level: warning
+  comments: disable
+  comments-indentation: disable
+  document-start: disable
+  empty-lines:
+    level: warning
+  hyphens:
+    level: warning
+  indentation:
+    level: warning
+    indent-sequences: consistent
+  line-length:
+    level: warning

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:
@@ -100,7 +105,8 @@ def validate_rule_conf(rule, conf):
                     'invalid config: unknown option "%s" for rule "%s"' %
                     (optkey, rule.ID))
             if type(options[optkey]) == tuple:
-                if conf[optkey] not in options[optkey]:
+                if (conf[optkey] not in options[optkey] and
+                        type(conf[optkey]) not in options[optkey]):
                     raise YamlLintConfigError(
                         'invalid config: option "%s" of "%s" should be in %s'
                         % (optkey, rule.ID, options[optkey]))
@@ -116,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
 
@@ -125,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

@@ -128,7 +128,7 @@ def run(input, conf):
     :param input: buffer, string or stream to read from
     :param conf: yamllint configuration object
     """
-    if type(input) == str:
+    if type(input) in (type(b''), type(u'')):  # compat with Python 2 & 3
         return _run(input, conf)
     elif hasattr(input, 'read'):  # Python 2's file or Python 3's io.IOBase
         # We need to have everything in memory to parse correctly

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

@@ -19,12 +19,16 @@ Use this rule to control the indentation.
 
 .. rubric:: Options
 
-* ``spaces`` defines the number of spaces that represent an indentation level.
+* ``spaces`` defines the indentation width, in spaces. Set either to an integer
+  (e.g. ``2`` or ``4``, representing the number of spaces in an indentation
+  level) or to ``consistent`` to allow any number, as long as it remains the
+  same within the file.
 * ``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
+  ``no``, ``whatever`` and ``consistent``. ``consistent`` requires either all
-  block sequences is OK.
+  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.
 
@@ -73,6 +77,28 @@ Use this rule to control the indentation.
         - haystack:
             needle
 
+#. With ``indentation: {spaces: consistent}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    history:
+       - name: Unix
+         date: 1969
+       - name: Linux
+         date: 1991
+    nest:
+       recurse:
+          - haystack:
+               needle
+
+   the following code snippet would **FAIL**:
+   ::
+
+    some:
+      Russian:
+          dolls
+
 #. With ``indentation: {spaces: 2, indent-sequences: no}``
 
    the following code snippet would **PASS**:
@@ -104,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**:
@@ -150,8 +198,8 @@ from yamllint.rules.common import is_explicit_key, get_real_end_line
 
 ID = 'indentation'
 TYPE = 'token'
-CONF = {'spaces': int,
+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)
@@ -174,45 +222,53 @@ def check_scalar_indentation(conf, token, context):
     if token.start_mark.line == token.end_mark.line:
         return
 
-    if token.plain:
+    def compute_expected_indent(found_indent):
-        expected_indent = token.start_mark.column
+        def detect_indent(base_indent):
-    elif token.style in ('"', "'"):
+            if type(context['spaces']) is not int:
-        expected_indent = token.start_mark.column + 1
+                context['spaces'] = found_indent - base_indent
-    elif token.style in ('>', '|'):
+            return base_indent + context['spaces']
-        if context['stack'][-1].type == B_SEQ:
+
-            # - >
+        if token.plain:
-            #     multi
+            return token.start_mark.column
-            #     line
+        elif token.style in ('"', "'"):
-            expected_indent = token.start_mark.column + conf['spaces']
+            return token.start_mark.column + 1
-        elif context['stack'][-1].type == KEY:
+        elif token.style in ('>', '|'):
-            assert context['stack'][-1].explicit_key
+            if context['stack'][-1].type == B_ENT:
-            # - ? >
+                # - >
-            #       multi-line
+                #     multi
-            #       key
+                #     line
-            #   : >
+                return detect_indent(token.start_mark.column)
-            #       multi-line
+            elif context['stack'][-1].type == KEY:
-            #       value
+                assert context['stack'][-1].explicit_key
-            expected_indent = token.start_mark.column + conf['spaces']
+                # - ? >
-        elif context['stack'][-1].type == VAL:
+                #       multi-line
-            if token.start_mark.line + 1 > context['cur_line']:
+                #       key
-                # - key:
-                #     >
-                #       multi
-                #       line
-                expected_indent = context['stack'][-1].indent + conf['spaces']
-            elif context['stack'][-2].explicit_key:
-                # - ? key
                 #   : >
                 #       multi-line
                 #       value
-                expected_indent = token.start_mark.column + conf['spaces']
+                return detect_indent(token.start_mark.column)
+            elif context['stack'][-1].type == VAL:
+                if token.start_mark.line + 1 > context['cur_line']:
+                    # - key:
+                    #     >
+                    #       multi
+                    #       line
+                    return detect_indent(context['stack'][-1].indent)
+                elif context['stack'][-2].explicit_key:
+                    # - ? key
+                    #   : >
+                    #       multi-line
+                    #       value
+                    return detect_indent(token.start_mark.column)
+                else:
+                    # - key: >
+                    #     multi
+                    #     line
+                    return detect_indent(context['stack'][-2].indent)
             else:
-                # - key: >
+                return detect_indent(context['stack'][-1].indent)
-                #     multi
+
-                #     line
+    expected_indent = None
-                expected_indent = context['stack'][-2].indent + conf['spaces']
-        else:
-            expected_indent = context['stack'][-1].indent + conf['spaces']
 
     line_no = token.start_mark.line + 1
 
@@ -230,16 +286,21 @@ def check_scalar_indentation(conf, token, context):
         if token.start_mark.buffer[line_start + indent] == '\n':
             continue
 
+        if expected_indent is None:
+            expected_indent = compute_expected_indent(indent)
+
         if indent != expected_indent:
             yield LintProblem(line_no, indent + 1,
                               'wrong indentation: expected %d but found %d' %
                               (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
 
@@ -250,6 +311,11 @@ 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(base_indent, next):
+        if type(context['spaces']) is not int:
+            context['spaces'] = next.start_mark.column - base_indent
+        return base_indent + context['spaces']
+
     if first_in_line:
         found_indentation = token.start_mark.column
         expected = context['stack'][-1].indent
@@ -260,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 += conf['spaces']
+            expected = detect_indent(expected, token)
 
         if found_indentation != expected:
             yield LintProblem(token.start_mark.line + 1, found_indentation + 1,
@@ -282,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:
+        assert next.start_mark.line == token.start_mark.line
-            #   - a: 1
+
-            #     b: 2
+        indent = token.start_mark.column
-            # or
-            #   - ? a
-            #     : 1
-            indent = token.start_mark.column
-        else:
-            #   - ?
-            #       a
-            #     : 1
-            indent = token.start_mark.column + conf['spaces']
 
         context['stack'].append(Parent(B_MAP, indent))
 
@@ -306,7 +371,7 @@ def check(conf, token, prev, next, nextnext, context):
             #   - {
             #     a: 1, b: 2
             #   }
-            indent = context['cur_line_indent'] + conf['spaces']
+            indent = detect_indent(context['cur_line_indent'], next)
 
         context['stack'].append(Parent(F_MAP, indent,
                                        line_indent=context['cur_line_indent']))
@@ -314,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
 
@@ -340,7 +405,7 @@ def check(conf, token, prev, next, nextnext, context):
             #   -
             #     key:
             #       value
-            indent = token.start_mark.column + conf['spaces']
+            indent = detect_indent(token.start_mark.column, next)
 
         context['stack'].append(Parent(B_ENT, indent))
 
@@ -352,7 +417,7 @@ def check(conf, token, prev, next, nextnext, context):
             #   - [
             #   a, b
             # ]
-            indent = context['cur_line_indent'] + conf['spaces']
+            indent = detect_indent(context['cur_line_indent'], next)
 
         context['stack'].append(Parent(F_SEQ, indent,
                                        line_indent=context['cur_line_indent']))
@@ -390,7 +455,7 @@ def check(conf, token, prev, next, nextnext, context):
                 #   ? k
                 #   :
                 #     value
-                indent = context['stack'][-1].indent + conf['spaces']
+                indent = detect_indent(context['stack'][-1].indent, next)
             elif next.start_mark.line == prev.start_mark.line:
                 #   k: value
                 indent = next.start_mark.column
@@ -401,37 +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:
+                elif context['indent-sequences'] is True:
-                    indent = context['stack'][-1].indent + conf['spaces']
+                    indent = detect_indent(context['stack'][-1].indent, next)
-                else:  # 'whatever'
+                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 + conf['spaces']
+                        indent = detect_indent(context['stack'][-1].indent,
+                                               next)
             else:
                 #   k:
                 #     value
-                indent = context['stack'][-1].indent + conf['spaces']
+                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
@@ -470,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: