yamllint version 1.14.0

Some usages of YAML (like Ansible) supports running the file as a script.

Support (by default) an ignore-shebangs setting for the comments module.

Fixes #116 - comments rule with require-starting-space: true should special case shebang

.gitignore

@@ -3,3 +3,4 @@ __pycache__
 /docs/_build
 /dist
 /yamllint.egg-info
+/build

.pre-commit-hooks.yaml

@@ -1,11 +1,11 @@
 ---
 
 # For use with pre-commit.
-# See usage instructions at http://pre-commit.com
+# See usage instructions at https://pre-commit.com
 
 - id: yamllint
   name: yamllint
   description: This hook runs yamllint.
   entry: yamllint
   language: python
-  files: \.(yaml|yml)$
+  types: [file, yaml]

.travis.yml

@@ -1,17 +1,24 @@
 ---
+dist: xenial  # required for Python >= 3.7 (travis-ci/travis-ci#9069)
 language: python
 python:
   - 2.7
-  - 3.3
   - 3.4
   - 3.5
+  - 3.6
+  - 3.7
   - nightly
 install:
-  - pip install pyyaml flake8 coveralls
+  - pip install pyyaml coveralls flake8 flake8-import-order doc8
+  - if [[ $TRAVIS_PYTHON_VERSION != 2* ]]; then pip install sphinx; fi
   - pip install .
 script:
-  - flake8 .
+  - if [[ $TRAVIS_PYTHON_VERSION != nightly ]]; then flake8 .; fi
+  - if [[ $TRAVIS_PYTHON_VERSION != 2* ]]; then doc8 $(git ls-files '*.rst'); fi
   - yamllint --strict $(git ls-files '*.yaml' '*.yml')
   - coverage run --source=yamllint setup.py test
+  - if [[ $TRAVIS_PYTHON_VERSION != 2* ]]; then
+      python setup.py build_sphinx;
+    fi
 after_success:
   coveralls

CHANGELOG.rst

@@ -0,0 +1,80 @@
+Changelog
+=========
+
+1.14.0 (2019-01-14)
+-------------------
+
+- Fix documentation code snippets
+- Drop Python 2.6 and 3.3 support, add Python 3.7 support
+- Update documentation and tests for ``line-length`` + Unicode + Python 2
+- Allow rule configurations to lack options
+- Add a new ``ignore-shebangs`` option for the ``comments`` rule
+
+1.13.0 (2018-11-14)
+-------------------
+
+- Use ``isinstance(x, y)`` instead of ``type(x) == y``
+- Add a new ``-f colored`` option
+- Update documentation about colored output when run from CLI
+
+1.12.1 (2018-10-17)
+-------------------
+
+- Fix the ``quoted-strings`` rule, broken implementation
+- Fix missing documentation for the ``quoted-strings`` rule
+
+1.12.0 (2018-10-04)
+-------------------
+
+- Add a new ``quoted-strings`` rule
+- Update installation documentation for pip, CentOS, Debian, Ubuntu, Mac OS
+
+1.11.1 (2018-04-06)
+-------------------
+
+- Handle merge keys (``<<``) in the ``key-duplicates`` rule
+- Update documentation about pre-commit
+- Make examples for ``ignore`` rule clearer
+- Clarify documentation on the 'truthy' rule
+- Fix crash in parser due to a change in PyYAML > 3.12
+
+1.11.0 (2018-02-21)
+-------------------
+
+- Add a new ``octal-values`` rule
+
+1.10.0 (2017-11-05)
+-------------------
+
+- Fix colored output on Windows
+- Check documentation compilation on continuous integration
+- Add a new ``empty-values`` rule
+- Make sure test files are included in dist bundle
+- Tests: Use en_US.UTF-8 locale when C.UTF-8 not available
+- Tests: Dynamically detect Python executable path
+
+1.9.0 (2017-10-16)
+------------------
+
+- Add a new ``key-ordering`` rule
+- Fix indentation rule for key following empty list
+
+1.8.2 (2017-10-10)
+------------------
+
+- Be clearer about the ``ignore`` conf type
+- Update pre-commit hook file
+- Add documentation for pre-commit
+
+1.8.1 (2017-07-04)
+------------------
+
+- Require pathspec >= 0.5.3
+- Support Python 2.6
+- Add a changelog
+
+1.8.0 (2017-06-28)
+------------------
+
+- Refactor argparse with mutually_exclusive_group
+- Add support to ignore paths in configuration

MANIFEST.in

@@ -1,3 +1,4 @@
 include LICENSE
 include README.rst
 include docs/*
+include tests/*.py tests/rules/*.py tests/yaml-1.2-spec-examples/*

README.rst

@@ -38,7 +38,8 @@ Screenshot
 Installation
 ^^^^^^^^^^^^
 
-On Fedora / CentOS:
+On Fedora / CentOS (note: `EPEL <https://fedoraproject.org/wiki/EPEL>`_ is
+required on CentOS):
 
 .. code:: bash
 
@@ -50,11 +51,17 @@ On Debian 8+ / Ubuntu 16.04+:
 
  sudo apt-get install yamllint
 
+On Mac OS 10.11+:
+
+.. code:: bash
+
+ brew install yamllint
+
 Alternatively using pip, the Python package manager:
 
 .. code:: bash
 
- sudo pip install yamllint
+ pip install --user yamllint
 
 Usage
 ^^^^^
@@ -119,6 +126,27 @@ or for a whole block:
    consectetur : adipiscing elit
  # yamllint enable
 
+Specific files can be ignored (totally or for some rules only) using a
+``.gitignore``-style pattern:
+
+.. code:: yaml
+
+ # For all rules
+ ignore: |
+   *.dont-lint-me.yaml
+   /bin/
+   !/bin/*.lint-me-anyway.yaml
+
+ rules:
+   key-duplicates:
+     ignore: |
+       generated
+       *.template.yaml
+   trailing-spaces:
+     ignore: |
+       *.ignore-trailing-spaces.yaml
+       /ascii-art/*
+
 `Read more in the complete documentation! <https://yamllint.readthedocs.io/>`_
 
 License

docs/conf.py

@@ -4,6 +4,7 @@
 
 import sys
 import os
+from unittest.mock import MagicMock
 
 sys.path.insert(0, os.path.abspath('..'))  # noqa
 
@@ -40,3 +41,15 @@ htmlhelp_basename = 'yamllintdoc'
 man_pages = [
     ('index', 'yamllint', '', [u'Adrien Vergé'], 1)
 ]
+
+# -- Build with sphinx automodule without needing to install third-party libs
+
+
+class Mock(MagicMock):
+    @classmethod
+    def __getattr__(cls, name):
+            return MagicMock()
+
+
+MOCK_MODULES = ['pathspec', 'yaml']
+sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)

docs/configuration.rst

@@ -45,9 +45,9 @@ It can be chosen using:
 Extending the default configuration
 -----------------------------------
 
-When writing a custom configuration file, you don't need to redefine every rule.
-Just extend the ``default`` configuration (or any already-existing configuration
-file).
+When writing a custom configuration file, you don't need to redefine every
+rule. Just extend the ``default`` configuration (or any already-existing
+configuration file).
 
 For instance, if you just want to disable the ``comments-indentation`` rule,
 your file could look like this:
@@ -102,11 +102,11 @@ Errors and warnings
 -------------------
 
 Problems detected by yamllint can be raised either as errors or as warnings.
-The CLI will output them (with different colors when using the ``standard``
-output format).
+The CLI will output them (with different colors when using the ``colored``
+output format, or ``auto`` when run from a terminal).
 
-By default the script will exit with a return code ``1`` *only when* there is one or
-more error(s).
+By default the script will exit with a return code ``1`` *only when* there is
+one or more error(s).
 
 However if strict mode is enabled with the ``-s`` (or ``--strict``) option, the
 return code will be:
@@ -114,3 +114,57 @@ return code will be:
  * ``0`` if no errors or warnings occur
  * ``1`` if one or more errors occur
  * ``2`` if no errors occur, but one or more warnings occur
+
+Ignoring paths
+--------------
+
+It is possible to exclude specific files or directories, so that the linter
+doesn't process them.
+
+You can either totally ignore files (they won't be looked at):
+
+.. code-block:: yaml
+
+ extends: default
+
+ ignore: |
+   /this/specific/file.yaml
+   all/this/directory/
+   *.template.yaml
+
+or ignore paths only for specific rules:
+
+.. code-block:: yaml
+
+ extends: default
+
+ rules:
+   trailing-spaces:
+     ignore: |
+       /this-file-has-trailing-spaces-but-it-is-OK.yaml
+       /generated/*.yaml
+
+Note that this ``.gitignore``-style path pattern allows complex path
+exclusion/inclusion, see the `pathspec README file
+<https://pypi.python.org/pypi/pathspec>`_ for more details.
+Here is a more complex example:
+
+.. code-block:: yaml
+
+ # For all rules
+ ignore: |
+   *.dont-lint-me.yaml
+   /bin/
+   !/bin/*.lint-me-anyway.yaml
+
+ extends: default
+
+ rules:
+   key-duplicates:
+     ignore: |
+       generated
+       *.template.yaml
+   trailing-spaces:
+     ignore: |
+       *.ignore-trailing-spaces.yaml
+       ascii-art/*

docs/disable_with_comments.rst

@@ -4,9 +4,9 @@ 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:
+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
 
@@ -46,9 +46,9 @@ If you need to disable multiple rules, it is allowed to chain rules like this:
 Disabling checks for all (or part of) the file
 ----------------------------------------------
 
-To prevent yamllint from reporting problems for the whole file, or for a block of
-lines within the file, use ``# yamllint disable ...`` and ``# yamllint enable
-...`` directive comments. For instance:
+To prevent yamllint from reporting problems for the whole file, or for a block
+of lines within the file, use ``# yamllint disable ...`` and ``# yamllint
+enable ...`` directive comments. For instance:
 
 .. code-block:: yaml
 

docs/index.rst

@@ -26,3 +26,4 @@ Table of contents
    disable_with_comments
    development
    text_editors
+   integration

docs/integration.rst

@@ -0,0 +1,17 @@
+Integration with other software
+===============================
+
+Integration with pre-commit
+---------------------------
+
+You can integrate yamllint in `pre-commit <http://pre-commit.com/>`_ tool.
+Here is an example, to add in your .pre-commit-config.yaml
+
+.. code:: yaml
+
+  ---
+  # Update the sha variable with the release version that you want, from the yamllint repo
+  - repo: https://github.com/adrienverge/yamllint.git
+    sha: v1.8.1
+    hooks:
+      - id: yamllint

docs/quickstart.rst

@@ -16,25 +16,24 @@ On Debian 8+ / Ubuntu 16.04+:
 
  sudo apt-get install yamllint
 
-On older Debian / Ubuntu versions:
+On Mac OS 10.11+:
 
 .. code:: bash
 
- sudo add-apt-repository -y ppa:adrienverge/ppa && sudo apt-get update
- sudo apt-get install yamllint
+ brew install yamllint
 
 Alternatively using pip, the Python package manager:
 
 .. code:: bash
 
- sudo pip install yamllint
+ pip install --user 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
+ pip install --user dist/yamllint-*.tar.gz
 
 Running yamllint
 ----------------
@@ -69,6 +68,10 @@ The output will look like (colors are not displayed here):
    10:1      error    too many blank lines (4 > 2)  (empty-lines)
    11:4      error    too many spaces inside braces  (braces)
 
+By default, the output of yamllint is colored when run from a terminal, and
+pure text in other cases. Add the ``-f standard`` arguments to force
+non-colored output. Use the ``-f colored`` arguments to force colored output.
+
 Add the ``-f parsable`` arguments if you need an output format parsable by a
 machine (for instance for :doc:`syntax highlighting in text editors
 <text_editors>`). The output will then look like:

docs/rules.rst

@@ -59,6 +59,11 @@ empty-lines
 
 .. automodule:: yamllint.rules.empty_lines
 
+empty-values
+------------
+
+.. automodule:: yamllint.rules.empty_values
+
 hyphens
 -------
 
@@ -74,6 +79,11 @@ key-duplicates
 
 .. automodule:: yamllint.rules.key_duplicates
 
+key-ordering
+--------------
+
+.. automodule:: yamllint.rules.key_ordering
+
 line-length
 -----------
 
@@ -89,6 +99,16 @@ new-lines
 
 .. automodule:: yamllint.rules.new_lines
 
+octal-values
+------------
+
+.. automodule:: yamllint.rules.octal_values
+
+quoted-strings
+--------------
+
+.. automodule:: yamllint.rules.quoted_strings
+
 trailing-spaces
 ---------------
 

setup.cfg

@@ -1,2 +1,12 @@
 [bdist_wheel]
 universal = 1
+
+[flake8]
+import-order-style = pep8
+application-import-names = yamllint
+
+[build_sphinx]
+all-files = 1
+source-dir = docs
+build-dir = docs/_build
+warning-is-error = 1

setup.py

@@ -29,13 +29,19 @@ setup(
     license=__license__,
     keywords=['yaml', 'lint', 'linter', 'syntax', 'checker'],
     url='https://github.com/adrienverge/yamllint',
+    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*',
     classifiers=[
         'Development Status :: 5 - Production/Stable',
         'Environment :: Console',
         'Intended Audience :: Developers',
         'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
         'Programming Language :: Python :: 2',
+        'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
         'Topic :: Software Development',
         'Topic :: Software Development :: Debuggers',
         'Topic :: Software Development :: Quality Assurance',
@@ -44,9 +50,7 @@ setup(
 
     packages=find_packages(exclude=['tests', 'tests.*']),
     entry_points={'console_scripts': ['yamllint=yamllint.cli:run']},
-    package_data={'yamllint': ['conf/*.yaml'],
-                  'tests': ['yaml-1.2-spec-examples/*']},
-    install_requires=['pyyaml'],
-    tests_require=['nose'],
-    test_suite='nose.collector',
+    package_data={'yamllint': ['conf/*.yaml']},
+    install_requires=['pathspec >=0.5.3', 'pyyaml'],
+    test_suite='tests',
 )

tests/common.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 os
+import tempfile
 import unittest
 
 import yaml
@@ -49,3 +51,21 @@ class RuleTestCase(unittest.TestCase):
 
         real_problems = list(linter.run(source, self.build_fake_config(conf)))
         self.assertEqual(real_problems, expected_problems)
+
+
+def build_temp_workspace(files):
+    tempdir = tempfile.mkdtemp(prefix='yamllint-tests-')
+
+    for path, content in files.items():
+        path = os.path.join(tempdir, path)
+        if not os.path.exists(os.path.dirname(path)):
+            os.makedirs(os.path.dirname(path))
+
+        if type(content) is list:
+            os.mkdir(path)
+        else:
+            mode = 'wb' if isinstance(content, bytes) else 'w'
+            with open(path, mode) as f:
+                f.write(content)
+
+    return tempdir

tests/rules/test_comments.py

@@ -80,6 +80,48 @@ class CommentsTestCase(RuleTestCase):
                    problem3=(9, 2), problem4=(10, 4),
                    problem5=(15, 3))
 
+    def test_shebang(self):
+        conf = ('comments:\n'
+                '  require-starting-space: true\n'
+                '  ignore-shebangs: false\n'
+                'comments-indentation: disable\n'
+                'document-start: disable\n')
+        self.check('#!/bin/env my-interpreter\n',
+                   conf, problem1=(1, 2))
+        self.check('# comment\n'
+                   '#!/bin/env my-interpreter\n', conf,
+                   problem1=(2, 2))
+        self.check('#!/bin/env my-interpreter\n'
+                   '---\n'
+                   '#comment\n'
+                   '#!/bin/env my-interpreter\n'
+                   '', conf,
+                   problem1=(1, 2), problem2=(3, 2), problem3=(4, 2))
+        self.check('#! not a shebang\n',
+                   conf, problem1=(1, 2))
+        self.check('key:  #!/not/a/shebang\n',
+                   conf, problem1=(1, 8))
+
+    def test_ignore_shebang(self):
+        conf = ('comments:\n'
+                '  require-starting-space: true\n'
+                '  ignore-shebangs: true\n'
+                'comments-indentation: disable\n'
+                'document-start: disable\n')
+        self.check('#!/bin/env my-interpreter\n', conf)
+        self.check('# comment\n'
+                   '#!/bin/env my-interpreter\n', conf,
+                   problem1=(2, 2))
+        self.check('#!/bin/env my-interpreter\n'
+                   '---\n'
+                   '#comment\n'
+                   '#!/bin/env my-interpreter\n', conf,
+                   problem2=(3, 2), problem3=(4, 2))
+        self.check('#! not a shebang\n',
+                   conf, problem1=(1, 2))
+        self.check('key:  #!/not/a/shebang\n',
+                   conf, problem1=(1, 8))
+
     def test_spaces_from_content(self):
         conf = ('comments:\n'
                 '  require-starting-space: false\n'

tests/rules/test_empty_values.py

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 Greg Dubicki
+#
+# 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 EmptyValuesTestCase(RuleTestCase):
+    rule_id = 'empty-values'
+
+    def test_disabled(self):
+        conf = ('empty-values: disable\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   'foo:\n', conf)
+        self.check('---\n'
+                   'foo:\n'
+                   ' bar:\n', conf)
+        self.check('---\n'
+                   '{a:}\n', conf)
+        self.check('---\n'
+                   'foo: {a:}\n', conf)
+        self.check('---\n'
+                   '- {a:}\n'
+                   '- {a:, b: 2}\n'
+                   '- {a: 1, b:}\n'
+                   '- {a: 1, b: , }\n', conf)
+        self.check('---\n'
+                   '{a: {b: , c: {d: 4, e:}}, f:}\n', conf)
+
+    def test_in_block_mappings_disabled(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n', conf)
+        self.check('---\n'
+                   'foo:\n'
+                   'bar: aaa\n', conf)
+
+    def test_in_block_mappings_single_line(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'implicitly-null:\n', conf, problem1=(2, 17))
+        self.check('---\n'
+                   'implicitly-null:with-colons:in-key:\n', conf,
+                   problem1=(2, 36))
+        self.check('---\n'
+                   'implicitly-null:with-colons:in-key2:\n', conf,
+                   problem1=(2, 37))
+
+    def test_in_block_mappings_all_lines(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   'bar:\n'
+                   'foobar:\n', conf, problem1=(2, 5),
+                   problem2=(3, 5), problem3=(4, 8))
+
+    def test_in_block_mappings_explicit_end_of_document(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   '...\n', conf, problem1=(2, 5))
+
+    def test_in_block_mappings_not_end_of_document(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   'bar:\n'
+                   ' aaa\n', conf, problem1=(2, 5))
+
+    def test_in_block_mappings_different_level(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   ' bar:\n'
+                   'aaa: bbb\n', conf, problem1=(3, 6))
+
+    def test_in_block_mappings_empty_flow_mapping(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   'foo: {a:}\n', conf)
+        self.check('---\n'
+                   '- {a:, b: 2}\n'
+                   '- {a: 1, b:}\n'
+                   '- {a: 1, b: , }\n', conf)
+
+    def test_in_block_mappings_empty_block_sequence(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   '  -\n', conf)
+
+    def test_in_block_mappings_not_empty_or_explicit_null(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   ' bar:\n'
+                   '  aaa\n', conf)
+        self.check('---\n'
+                   'explicitly-null: null\n', conf)
+        self.check('---\n'
+                   'explicitly-null:with-colons:in-key: null\n', conf)
+        self.check('---\n'
+                   'false-null: nulL\n', conf)
+        self.check('---\n'
+                   'empty-string: \'\'\n', conf)
+        self.check('---\n'
+                   'nullable-boolean: false\n', conf)
+        self.check('---\n'
+                   'nullable-int: 0\n', conf)
+        self.check('---\n'
+                   'First occurrence: &anchor Foo\n'
+                   'Second occurrence: *anchor\n', conf)
+
+    def test_in_block_mappings_various_explicit_null(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'null-alias: ~\n', conf)
+        self.check('---\n'
+                   'null-key1: {?: val}\n', conf)
+        self.check('---\n'
+                   'null-key2: {? !!null "": val}\n', conf)
+
+    def test_in_block_mappings_comments(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n'
+                'comments: disable\n')
+        self.check('---\n'
+                   'empty:  # comment\n'
+                   'foo:\n'
+                   '  bar: # comment\n', conf,
+                   problem1=(2, 7),
+                   problem2=(4, 7))
+
+    def test_in_flow_mappings_disabled(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: false}\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   '{a:}\n', conf)
+        self.check('---\n'
+                   'foo: {a:}\n', conf)
+        self.check('---\n'
+                   '- {a:}\n'
+                   '- {a:, b: 2}\n'
+                   '- {a: 1, b:}\n'
+                   '- {a: 1, b: , }\n', conf)
+        self.check('---\n'
+                   '{a: {b: , c: {d: 4, e:}}, f:}\n', conf)
+
+    def test_in_flow_mappings_single_line(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: true}\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   '{a:}\n', conf,
+                   problem=(2, 4))
+        self.check('---\n'
+                   'foo: {a:}\n', conf,
+                   problem=(2, 9))
+        self.check('---\n'
+                   '- {a:}\n'
+                   '- {a:, b: 2}\n'
+                   '- {a: 1, b:}\n'
+                   '- {a: 1, b: , }\n', conf,
+                   problem1=(2, 6),
+                   problem2=(3, 6),
+                   problem3=(4, 12),
+                   problem4=(5, 12))
+        self.check('---\n'
+                   '{a: {b: , c: {d: 4, e:}}, f:}\n', conf,
+                   problem1=(2, 8),
+                   problem2=(2, 23),
+                   problem3=(2, 29))
+
+    def test_in_flow_mappings_multi_line(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: true}\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   'foo: {\n'
+                   '  a:\n'
+                   '}\n', conf,
+                   problem=(3, 5))
+        self.check('---\n'
+                   '{\n'
+                   '  a: {\n'
+                   '    b: ,\n'
+                   '    c: {\n'
+                   '      d: 4,\n'
+                   '      e:\n'
+                   '    }\n'
+                   '  },\n'
+                   '  f:\n'
+                   '}\n', conf,
+                   problem1=(4, 7),
+                   problem2=(7, 9),
+                   problem3=(10, 5))
+
+    def test_in_flow_mappings_various_explicit_null(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: true}\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   '{explicit-null: null}\n', conf)
+        self.check('---\n'
+                   '{null-alias: ~}\n', conf)
+        self.check('---\n'
+                   'null-key1: {?: val}\n', conf)
+        self.check('---\n'
+                   'null-key2: {? !!null "": val}\n', conf)
+
+    def test_in_flow_mappings_comments(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: true}\n'
+                'braces: disable\n'
+                'commas: disable\n'
+                'comments: disable\n')
+        self.check('---\n'
+                   '{\n'
+                   '  a: {\n'
+                   '    b: ,  # comment\n'
+                   '    c: {\n'
+                   '      d: 4,  # comment\n'
+                   '      e:  # comment\n'
+                   '    }\n'
+                   '  },\n'
+                   '  f:  # comment\n'
+                   '}\n', conf,
+                   problem1=(4, 7),
+                   problem2=(7, 9),
+                   problem3=(10, 5))

tests/rules/test_indentation.py

@@ -15,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from tests.common import RuleTestCase
+
 from yamllint.parser import token_or_comment_generator, Comment
 from yamllint.rules.indentation import check
 
@@ -50,8 +51,8 @@ class IndentationStackTestCase(RuleTestCase):
                           .replace('Mapping', 'Map'))
             if token_type in ('StreamStart', 'StreamEnd'):
                 continue
-            output += '%9s %s\n' % (token_type,
-                                    self.format_stack(context['stack']))
+            output += '{:>9} {}\n'.format(token_type,
+                                          self.format_stack(context['stack']))
         return output
 
     def test_simple_mapping(self):
@@ -589,6 +590,9 @@ class IndentationTestCase(RuleTestCase):
                    '    date: 1969\n'
                    '  - name: Linux\n'
                    '    date: 1991\n'
+                   '  k4:\n'
+                   '  -\n'
+                   '  k5: v3\n'
                    '...\n', conf)
         conf = 'indentation: {spaces: 2, indent-sequences: true}'
         self.check('---\n'
@@ -1208,6 +1212,20 @@ class IndentationTestCase(RuleTestCase):
                    '        - name: Linux\n'
                    '         date: 1991\n'
                    '...\n', conf, problem=(5, 10, 'syntax'))
+        conf = 'indentation: {spaces: 2, indent-sequences: true}'
+        self.check('---\n'
+                   'a:\n'
+                   '-\n'  # empty list
+                   'b: c\n'
+                   '...\n', conf, problem=(3, 1))
+        conf = 'indentation: {spaces: 2, indent-sequences: consistent}'
+        self.check('---\n'
+                   'a:\n'
+                   '  -\n'  # empty list
+                   'b:\n'
+                   '-\n'
+                   'c: d\n'
+                   '...\n', conf, problem=(5, 1))
 
     def test_over_indented(self):
         conf = 'indentation: {spaces: 2, indent-sequences: consistent}'
@@ -1264,6 +1282,20 @@ class IndentationTestCase(RuleTestCase):
                    '    - subel\n'
                    '...\n', conf,
                    problem=(2, 3))
+        conf = 'indentation: {spaces: 2, indent-sequences: false}'
+        self.check('---\n'
+                   'a:\n'
+                   '  -\n'  # empty list
+                   'b: c\n'
+                   '...\n', conf, problem=(3, 3))
+        conf = 'indentation: {spaces: 2, indent-sequences: consistent}'
+        self.check('---\n'
+                   'a:\n'
+                   '-\n'  # empty list
+                   'b:\n'
+                   '  -\n'
+                   'c: d\n'
+                   '...\n', conf, problem=(5, 3))
 
     def test_multi_lines(self):
         conf = 'indentation: {spaces: consistent, indent-sequences: true}'

tests/rules/test_key_duplicates.py

@@ -78,6 +78,15 @@ class KeyDuplicatesTestCase(RuleTestCase):
                    '    duplicates with\n'
                    '    many styles\n'
                    ': 1\n', conf)
+        self.check('---\n'
+                   'Merge Keys are OK:\n'
+                   'anchor_one: &anchor_one\n'
+                   '  one: one\n'
+                   'anchor_two: &anchor_two\n'
+                   '  two: two\n'
+                   'anchor_reference:\n'
+                   '  <<: *anchor_one\n'
+                   '  <<: *anchor_two\n', conf)
 
     def test_enabled(self):
         conf = 'key-duplicates: enable'
@@ -147,6 +156,15 @@ class KeyDuplicatesTestCase(RuleTestCase):
                    ': 1\n', conf,
                    problem1=(3, 1), problem2=(4, 1), problem3=(5, 3),
                    problem4=(7, 3))
+        self.check('---\n'
+                   'Merge Keys are OK:\n'
+                   'anchor_one: &anchor_one\n'
+                   '  one: one\n'
+                   'anchor_two: &anchor_two\n'
+                   '  two: two\n'
+                   'anchor_reference:\n'
+                   '  <<: *anchor_one\n'
+                   '  <<: *anchor_two\n', conf)
 
     def test_key_tokens_in_flow_sequences(self):
         conf = 'key-duplicates: enable'

tests/rules/test_key_ordering.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 Johannes F. Knauf
+#
+# 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 KeyOrderingTestCase(RuleTestCase):
+    rule_id = 'key-ordering'
+
+    def test_disabled(self):
+        conf = 'key-ordering: disable'
+        self.check('---\n'
+                   'block mapping:\n'
+                   '  secondkey: a\n'
+                   '  firstkey: b\n', conf)
+        self.check('---\n'
+                   'flow mapping:\n'
+                   '  {secondkey: a, firstkey: b}\n', conf)
+        self.check('---\n'
+                   'second: before_first\n'
+                   'at: root\n', conf)
+        self.check('---\n'
+                   'nested but OK:\n'
+                   '  second: {first: 1}\n'
+                   '  third:\n'
+                   '    second: 2\n', conf)
+
+    def test_enabled(self):
+        conf = 'key-ordering: enable'
+        self.check('---\n'
+                   'block mapping:\n'
+                   '  secondkey: a\n'
+                   '  firstkey: b\n', conf,
+                   problem=(4, 3))
+        self.check('---\n'
+                   'flow mapping:\n'
+                   '  {secondkey: a, firstkey: b}\n', conf,
+                   problem=(3, 18))
+        self.check('---\n'
+                   'second: before_first\n'
+                   'at: root\n', conf,
+                   problem=(3, 1))
+        self.check('---\n'
+                   'nested but OK:\n'
+                   '  second: {first: 1}\n'
+                   '  third:\n'
+                   '    second: 2\n', conf)
+
+    def test_word_length(self):
+        conf = 'key-ordering: enable'
+        self.check('---\n'
+                   'a: 1\n'
+                   'ab: 1\n'
+                   'abc: 1\n', conf)
+        self.check('---\n'
+                   'a: 1\n'
+                   'abc: 1\n'
+                   'ab: 1\n', conf,
+                   problem=(4, 1))
+
+    def test_key_duplicates(self):
+        conf = ('key-duplicates: disable\n'
+                'key-ordering: enable')
+        self.check('---\n'
+                   'key: 1\n'
+                   'key: 2\n', conf)
+
+    def test_case(self):
+        conf = 'key-ordering: enable'
+        self.check('---\n'
+                   'T-shirt: 1\n'
+                   'T-shirts: 2\n'
+                   't-shirt: 3\n'
+                   't-shirts: 4\n', conf)
+        self.check('---\n'
+                   'T-shirt: 1\n'
+                   't-shirt: 2\n'
+                   'T-shirts: 3\n'
+                   't-shirts: 4\n', conf,
+                   problem=(4, 1))
+
+    def test_accents(self):
+        conf = 'key-ordering: enable'
+        self.check('---\n'
+                   'hair: true\n'
+                   'hais: true\n'
+                   'haïr: true\n'
+                   'haïssable: true\n', conf)
+        self.check('---\n'
+                   'haïr: true\n'
+                   'hais: true\n', conf,
+                   problem=(3, 1))
+        self.check('---\n'
+                   'haïr: true\n'
+                   'hais: true\n', conf,
+                   problem=(3, 1))
+
+    def test_key_tokens_in_flow_sequences(self):
+        conf = 'key-ordering: enable'
+        self.check('---\n'
+                   '[\n'
+                   '  key: value, mappings, in, flow: sequence\n'
+                   ']\n', conf)

tests/rules/test_line_length.py

@@ -14,6 +14,9 @@
 # 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 sys
+import unittest
+
 from tests.common import RuleTestCase
 
 
@@ -155,3 +158,16 @@ class LineLengthTestCase(RuleTestCase):
                    'content: |\n'
                    '  {% this line is' + 99 * ' really' + ' long %}\n',
                    conf, problem=(3, 81))
+
+    @unittest.skipIf(sys.version_info < (3, 0), 'Python 2 not supported')
+    def test_unicode(self):
+        conf = 'line-length: {max: 53}'
+        self.check('---\n'
+                   '# This is a test to check if “line-length” works nice\n'
+                   'with: “unicode characters” that span accross bytes! ↺\n',
+                   conf)
+        conf = 'line-length: {max: 52}'
+        self.check('---\n'
+                   '# This is a test to check if “line-length” works nice\n'
+                   'with: “unicode characters” that span accross bytes! ↺\n',
+                   conf, problem1=(2, 53), problem2=(3, 53))

tests/rules/test_octal_values.py

@@ -0,0 +1,72 @@
+# -*- 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 OctalValuesTestCase(RuleTestCase):
+    rule_id = 'octal-values'
+
+    def test_disabled(self):
+        conf = ('octal-values: disable\n'
+                'new-line-at-end-of-file: disable\n'
+                'document-start: disable\n')
+        self.check('user-city: 010', conf)
+        self.check('user-city: 0o10', conf)
+
+    def test_implicit_octal_values(self):
+        conf = ('octal-values: {forbid-implicit-octal: true}\n'
+                'new-line-at-end-of-file: disable\n'
+                'document-start: disable\n')
+        self.check('user-city: 010', conf, problem=(1, 15))
+        self.check('user-city: abc', conf)
+        self.check('user-city: 010,0571', conf)
+        self.check("user-city: '010'", conf)
+        self.check('user-city: "010"', conf)
+        self.check('user-city:\n'
+                   '  - 010', conf, problem=(2, 8))
+        self.check('user-city: [010]', conf, problem=(1, 16))
+        self.check('user-city: {beijing: 010}', conf, problem=(1, 25))
+        self.check('explicit-octal: 0o10', conf)
+        self.check('not-number: 0abc', conf)
+        self.check('zero: 0', conf)
+        self.check('hex-value: 0x10', conf)
+        self.check('number-values:\n'
+                   '  - 0.10\n'
+                   '  - .01\n'
+                   '  - 0e3\n', conf)
+
+    def test_explicit_octal_values(self):
+        conf = ('octal-values: {forbid-explicit-octal: true}\n'
+                'new-line-at-end-of-file: disable\n'
+                'document-start: disable\n')
+        self.check('user-city: 0o10', conf, problem=(1, 16))
+        self.check('user-city: abc', conf)
+        self.check('user-city: 0o10,0571', conf)
+        self.check("user-city: '0o10'", conf)
+        self.check('user-city:\n'
+                   '  - 0o10', conf, problem=(2, 9))
+        self.check('user-city: [0o10]', conf, problem=(1, 17))
+        self.check('user-city: {beijing: 0o10}', conf, problem=(1, 26))
+        self.check('implicit-octal: 010', conf)
+        self.check('not-number: 0oabc', conf)
+        self.check('zero: 0', conf)
+        self.check('hex-value: 0x10', conf)
+        self.check('number-values:\n'
+                   '  - 0.10\n'
+                   '  - .01\n'
+                   '  - 0e3\n', conf)
+        self.check('user-city: "010"', conf)

tests/rules/test_quoted_strings.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018 ClearScore
+#
+# 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 QuotedTestCase(RuleTestCase):
+    rule_id = 'quoted-strings'
+
+    def test_disabled(self):
+        conf = 'quoted-strings: disable'
+        self.check('---\n'
+                   'foo: bar\n', conf)
+        self.check('---\n'
+                   'foo: "bar"\n', conf)
+        self.check('---\n'
+                   'foo: \'bar\'\n', conf)
+        self.check('---\n'
+                   'bar: 123\n', conf)
+
+    def test_quote_type_any(self):
+        conf = 'quoted-strings: {quote-type: any}\n'
+        self.check('---\n'
+                   'boolean1: true\n'
+                   'number1: 123\n'
+                   'string1: foo\n'                          # fails
+                   'string2: "foo"\n'
+                   'string3: \'bar\'\n'
+                   'string4: !!str genericstring\n'
+                   'string5: !!str 456\n'
+                   'string6: !!str "quotedgenericstring"\n'
+                   'binary: !!binary binstring\n'
+                   'integer: !!int intstring\n'
+                   'boolean2: !!bool boolstring\n'
+                   'boolean3: !!bool "quotedboolstring"\n',
+                   conf, problem=(4, 10))
+        self.check('---\n'
+                   'multiline string 1: |\n'
+                   '  line 1\n'
+                   '  line 2\n'
+                   'multiline string 2: >\n'
+                   '  word 1\n'
+                   '  word 2\n'
+                   'multiline string 3:\n'
+                   '  word 1\n'
+                   '  word 2\n'
+                   'multiline string 4:\n'
+                   '  "word 1\\\n'
+                   '   word 2"\n',
+                   conf, problem1=(9, 3))
+
+    def test_quote_type_single(self):
+        conf = 'quoted-strings: {quote-type: single}\n'
+        self.check('---\n'
+                   'boolean1: true\n'
+                   'number1: 123\n'
+                   'string1: foo\n'                          # fails
+                   'string2: "foo"\n'                        # fails
+                   'string3: \'bar\'\n'
+                   'string4: !!str genericstring\n'
+                   'string5: !!str 456\n'
+                   'string6: !!str "quotedgenericstring"\n'
+                   'binary: !!binary binstring\n'
+                   'integer: !!int intstring\n'
+                   'boolean2: !!bool boolstring\n'
+                   'boolean3: !!bool "quotedboolstring"\n',
+                   conf, problem1=(4, 10), problem2=(5, 10))
+        self.check('---\n'
+                   'multiline string 1: |\n'
+                   '  line 1\n'
+                   '  line 2\n'
+                   'multiline string 2: >\n'
+                   '  word 1\n'
+                   '  word 2\n'
+                   'multiline string 3:\n'
+                   '  word 1\n'
+                   '  word 2\n'
+                   'multiline string 4:\n'
+                   '  "word 1\\\n'
+                   '   word 2"\n',
+                   conf, problem1=(9, 3), problem2=(12, 3))
+
+    def test_quote_type_double(self):
+        conf = 'quoted-strings: {quote-type: double}\n'
+        self.check('---\n'
+                   'boolean1: true\n'
+                   'number1: 123\n'
+                   'string1: foo\n'                          # fails
+                   'string2: "foo"\n'
+                   'string3: \'bar\'\n'                      # fails
+                   'string4: !!str genericstring\n'
+                   'string5: !!str 456\n'
+                   'string6: !!str "quotedgenericstring"\n'
+                   'binary: !!binary binstring\n'
+                   'integer: !!int intstring\n'
+                   'boolean2: !!bool boolstring\n'
+                   'boolean3: !!bool "quotedboolstring"\n',
+                   conf, problem1=(4, 10), problem2=(6, 10))
+        self.check('---\n'
+                   'multiline string 1: |\n'
+                   '  line 1\n'
+                   '  line 2\n'
+                   'multiline string 2: >\n'
+                   '  word 1\n'
+                   '  word 2\n'
+                   'multiline string 3:\n'
+                   '  word 1\n'
+                   '  word 2\n'
+                   'multiline string 4:\n'
+                   '  "word 1\\\n'
+                   '   word 2"\n',
+                   conf, problem1=(9, 3))

tests/test_cli.py

@@ -23,65 +23,54 @@ import locale
 import os
 import pty
 import shutil
-import tempfile
-import unittest
 import sys
+import unittest
+
+from tests.common import build_temp_workspace
 
 from yamllint import cli
 
 
 class CommandLineTestCase(unittest.TestCase):
-    def setUp(self):
-        self.wd = tempfile.mkdtemp(prefix='yamllint-tests-')
+    @classmethod
+    def setUpClass(cls):
+        super(CommandLineTestCase, cls).setUpClass()
 
-        # .yaml file at root
-        with open(os.path.join(self.wd, 'a.yaml'), 'w') as f:
-            f.write('---\n'
-                    '- 1   \n'
-                    '- 2')
+        cls.wd = build_temp_workspace({
+            # .yaml file at root
+            'a.yaml': '---\n'
+                      '- 1   \n'
+                      '- 2',
+            # file with only one warning
+            'warn.yaml': 'key: value\n',
+            # .yml file at root
+            'empty.yml': '',
+            # file in dir
+            'sub/ok.yaml': '---\n'
+                           'key: value\n',
+            # file in very nested dir
+            's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml': '---\n'
+                                                       'key: value\n'
+                                                       'key: other value\n',
+            # empty dir
+            'empty-dir': [],
+            # non-YAML file
+            'no-yaml.json': '---\n'
+                            'key: value\n',
+            # non-ASCII chars
+            'non-ascii/utf-8': (
+                u'---\n'
+                u'- hétérogénéité\n'
+                u'# 19.99 €\n'
+                u'- お早う御座います。\n'
+                u'# الأَبْجَدِيَّة العَرَبِيَّة\n').encode('utf-8'),
+        })
 
-        # file with only one warning
-        with open(os.path.join(self.wd, 'warn.yaml'), 'w') as f:
-            f.write('key: value\n')
+    @classmethod
+    def tearDownClass(cls):
+        super(CommandLineTestCase, cls).tearDownClass()
 
-        # .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')
-
-        # non-ASCII chars
-        os.mkdir(os.path.join(self.wd, 'non-ascii'))
-        with open(os.path.join(self.wd, 'non-ascii', 'utf-8'), 'wb') as f:
-            f.write((u'---\n'
-                     u'- hétérogénéité\n'
-                     u'# 19.99 €\n'
-                     u'- お早う御座います。\n'
-                     u'# الأَبْجَدِيَّة العَرَبِيَّة\n').encode('utf-8'))
-
-    def tearDown(self):
-        shutil.rmtree(self.wd)
+        shutil.rmtree(cls.wd)
 
     def test_find_files_recursively(self):
         self.assertEqual(
@@ -145,8 +134,11 @@ class CommandLineTestCase(unittest.TestCase):
 
         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')
+        self.assertRegexpMatches(
+            err.splitlines()[-1],
+            r'^yamllint: error: argument -d\/--config-data: '
+            r'not allowed with argument -c\/--config-file$'
+        )
 
     def test_run_with_bad_config(self):
         sys.stdout, sys.stderr = StringIO(), StringIO()
@@ -302,7 +294,10 @@ class CommandLineTestCase(unittest.TestCase):
         # Make sure the default localization conditions on this "system"
         # support UTF-8 encoding.
         loc = locale.getlocale()
-        locale.setlocale(locale.LC_ALL, 'C.UTF-8')
+        try:
+            locale.setlocale(locale.LC_ALL, 'C.UTF-8')
+        except locale.Error:
+            locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
 
         sys.stdout, sys.stderr = StringIO(), StringIO()
         with self.assertRaises(SystemExit) as ctx:
@@ -351,7 +346,7 @@ class CommandLineTestCase(unittest.TestCase):
             '\n' % file))
         self.assertEqual(err, '')
 
-    def test_run_colored_output(self):
+    def test_run_default_format_output_in_tty(self):
         file = os.path.join(self.wd, 'a.yaml')
 
         # Create a pseudo-TTY and redirect stdout to it
@@ -383,3 +378,59 @@ class CommandLineTestCase(unittest.TestCase):
             'no new line character at the end of file  '
             '\033[2m(new-line-at-end-of-file)\033[0m\n'
             '\n' % file))
+
+    def test_run_default_format_output_without_tty(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, (
+            '%s\n'
+            '  2:4       error    trailing spaces  (trailing-spaces)\n'
+            '  3:4       error    no new line character at the end of file  '
+            '(new-line-at-end-of-file)\n'
+            '\n' % file))
+        self.assertEqual(err, '')
+
+    def test_run_auto_output_without_tty_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, '--format', 'auto'))
+
+        self.assertEqual(ctx.exception.code, 1)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, (
+            '%s\n'
+            '  2:4       error    trailing spaces  (trailing-spaces)\n'
+            '  3:4       error    no new line character at the end of file  '
+            '(new-line-at-end-of-file)\n'
+            '\n' % file))
+        self.assertEqual(err, '')
+
+    def test_run_format_colored(self):
+        file = os.path.join(self.wd, 'a.yaml')
+
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run((file, '--format', 'colored'))
+
+        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

@@ -14,8 +14,19 @@
 # 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 sys
+import tempfile
 import unittest
 
+from tests.common import build_temp_workspace
+
+from yamllint import cli
 from yamllint import config
 
 
@@ -30,7 +41,7 @@ class SimpleConfigTestCase(unittest.TestCase):
         self.assertEqual(new.rules['colons']['max-spaces-before'], 0)
         self.assertEqual(new.rules['colons']['max-spaces-after'], 1)
 
-        self.assertEqual(len(new.enabled_rules()), 1)
+        self.assertEqual(len(new.enabled_rules(None)), 1)
 
     def test_invalid_conf(self):
         with self.assertRaises(config.YamlLintConfigError):
@@ -44,13 +55,16 @@ class SimpleConfigTestCase(unittest.TestCase):
                                   '  this-one-does-not-exist: enable\n')
 
     def test_missing_option(self):
-        with self.assertRaisesRegexp(
-                config.YamlLintConfigError,
-                'invalid config: missing option "max-spaces-before" '
-                'for rule "colons"'):
-            config.YamlLintConfig('rules:\n'
+        c = config.YamlLintConfig('rules:\n'
+                                  '  colons: enable\n')
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
+
+        c = config.YamlLintConfig('rules:\n'
                                   '  colons:\n'
-                                  '    max-spaces-after: 1\n')
+                                  '    max-spaces-before: 9\n')
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 9)
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
 
     def test_unknown_option(self):
         with self.assertRaisesRegexp(
@@ -68,7 +82,7 @@ class SimpleConfigTestCase(unittest.TestCase):
                                   '    spaces: 2\n'
                                   '    indent-sequences: true\n'
                                   '    check-multi-line-strings: false\n')
-        self.assertEqual(c.rules['indentation']['indent-sequences'], True)
+        self.assertTrue(c.rules['indentation']['indent-sequences'])
         self.assertEqual(c.rules['indentation']['check-multi-line-strings'],
                          False)
 
@@ -77,7 +91,7 @@ class SimpleConfigTestCase(unittest.TestCase):
                                   '    spaces: 2\n'
                                   '    indent-sequences: yes\n'
                                   '    check-multi-line-strings: false\n')
-        self.assertEqual(c.rules['indentation']['indent-sequences'], True)
+        self.assertTrue(c.rules['indentation']['indent-sequences'])
         self.assertEqual(c.rules['indentation']['check-multi-line-strings'],
                          False)
 
@@ -101,17 +115,22 @@ class SimpleConfigTestCase(unittest.TestCase):
                                       '    indent-sequences: YES!\n'
                                       '    check-multi-line-strings: false\n')
 
+    def test_enable_disable_keywords(self):
+        c = config.YamlLintConfig('rules:\n'
+                                  '  colons: enable\n'
+                                  '  hyphens: disable\n')
+        self.assertEqual(c.rules['colons'], {'level': 'error',
+                                             'max-spaces-after': 1,
+                                             'max-spaces-before': 0})
+        self.assertEqual(c.rules['hyphens'], False)
+
     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.assertFalse(config.validate_rule_conf(Rule, 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'})
@@ -119,22 +138,22 @@ class SimpleConfigTestCase(unittest.TestCase):
                           config.validate_rule_conf, Rule, {'level': 'warn'})
 
         Rule.CONF = {'length': int}
+        Rule.DEFAULT = {'length': 80}
         config.validate_rule_conf(Rule, {'length': 8})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule, {})
+        config.validate_rule_conf(Rule, {})
         self.assertRaises(config.YamlLintConfigError,
                           config.validate_rule_conf, Rule, {'height': 8})
 
         Rule.CONF = {'a': bool, 'b': int}
+        Rule.DEFAULT = {'a': True, 'b': -42}
         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})
+        config.validate_rule_conf(Rule, {'a': True})
+        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')}
+        Rule.DEFAULT = {'choice': 88}
         config.validate_rule_conf(Rule, {'choice': True})
         config.validate_rule_conf(Rule, {'choice': 88})
         config.validate_rule_conf(Rule, {'choice': 'str'})
@@ -146,8 +165,10 @@ class SimpleConfigTestCase(unittest.TestCase):
                           config.validate_rule_conf, Rule, {'choice': 'abc'})
 
         Rule.CONF = {'choice': (int, 'hardcoded')}
+        Rule.DEFAULT = {'choice': 1337}
         config.validate_rule_conf(Rule, {'choice': 42})
         config.validate_rule_conf(Rule, {'choice': 'hardcoded'})
+        config.validate_rule_conf(Rule, {})
         self.assertRaises(config.YamlLintConfigError,
                           config.validate_rule_conf, Rule, {'choice': False})
         self.assertRaises(config.YamlLintConfigError,
@@ -155,7 +176,7 @@ class SimpleConfigTestCase(unittest.TestCase):
 
 
 class ExtendedConfigTestCase(unittest.TestCase):
-    def test_extend_add_rule(self):
+    def test_extend_on_object(self):
         old = config.YamlLintConfig('rules:\n'
                                     '  colons:\n'
                                     '    max-spaces-before: 0\n'
@@ -170,62 +191,132 @@ class ExtendedConfigTestCase(unittest.TestCase):
         self.assertEqual(new.rules['colons']['max-spaces-after'], 1)
         self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
 
-        self.assertEqual(len(new.enabled_rules()), 2)
+        self.assertEqual(len(new.enabled_rules(None)), 2)
+
+    def test_extend_on_file(self):
+        with tempfile.NamedTemporaryFile('w') as f:
+            f.write('rules:\n'
+                    '  colons:\n'
+                    '    max-spaces-before: 0\n'
+                    '    max-spaces-after: 1\n')
+            f.flush()
+            c = config.YamlLintConfig('extends: ' + f.name + '\n'
+                                      'rules:\n'
+                                      '  hyphens:\n'
+                                      '    max-spaces-after: 2\n')
+
+        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
+        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
+
+        self.assertEqual(len(c.enabled_rules(None)), 2)
 
     def test_extend_remove_rule(self):
-        old = config.YamlLintConfig('rules:\n'
-                                    '  colons:\n'
-                                    '    max-spaces-before: 0\n'
-                                    '    max-spaces-after: 1\n'
-                                    '  hyphens:\n'
-                                    '    max-spaces-after: 2\n')
-        new = config.YamlLintConfig('rules:\n'
-                                    '  colons: disable\n')
-        new.extend(old)
+        with tempfile.NamedTemporaryFile('w') as f:
+            f.write('rules:\n'
+                    '  colons:\n'
+                    '    max-spaces-before: 0\n'
+                    '    max-spaces-after: 1\n'
+                    '  hyphens:\n'
+                    '    max-spaces-after: 2\n')
+            f.flush()
+            c = config.YamlLintConfig('extends: ' + f.name + '\n'
+                                      'rules:\n'
+                                      '  colons: disable\n')
 
-        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(new.rules['colons'], False)
-        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
+        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
+        self.assertFalse(c.rules['colons'])
+        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
 
-        self.assertEqual(len(new.enabled_rules()), 1)
+        self.assertEqual(len(c.enabled_rules(None)), 1)
 
     def test_extend_edit_rule(self):
-        old = config.YamlLintConfig('rules:\n'
-                                    '  colons:\n'
-                                    '    max-spaces-before: 0\n'
-                                    '    max-spaces-after: 1\n'
-                                    '  hyphens:\n'
-                                    '    max-spaces-after: 2\n')
-        new = config.YamlLintConfig('rules:\n'
-                                    '  colons:\n'
-                                    '    max-spaces-before: 3\n'
-                                    '    max-spaces-after: 4\n')
-        new.extend(old)
+        with tempfile.NamedTemporaryFile('w') as f:
+            f.write('rules:\n'
+                    '  colons:\n'
+                    '    max-spaces-before: 0\n'
+                    '    max-spaces-after: 1\n'
+                    '  hyphens:\n'
+                    '    max-spaces-after: 2\n')
+            f.flush()
+            c = config.YamlLintConfig('extends: ' + f.name + '\n'
+                                      'rules:\n'
+                                      '  colons:\n'
+                                      '    max-spaces-before: 3\n'
+                                      '    max-spaces-after: 4\n')
 
-        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(new.rules['colons']['max-spaces-before'], 3)
-        self.assertEqual(new.rules['colons']['max-spaces-after'], 4)
-        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
+        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 3)
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 4)
+        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
 
-        self.assertEqual(len(new.enabled_rules()), 2)
+        self.assertEqual(len(c.enabled_rules(None)), 2)
 
     def test_extend_reenable_rule(self):
-        old = config.YamlLintConfig('rules:\n'
-                                    '  colons:\n'
-                                    '    max-spaces-before: 0\n'
-                                    '    max-spaces-after: 1\n'
-                                    '  hyphens: disable\n')
-        new = config.YamlLintConfig('rules:\n'
-                                    '  hyphens:\n'
-                                    '    max-spaces-after: 2\n')
-        new.extend(old)
+        with tempfile.NamedTemporaryFile('w') as f:
+            f.write('rules:\n'
+                    '  colons:\n'
+                    '    max-spaces-before: 0\n'
+                    '    max-spaces-after: 1\n'
+                    '  hyphens: disable\n')
+            f.flush()
+            c = config.YamlLintConfig('extends: ' + f.name + '\n'
+                                      'rules:\n'
+                                      '  hyphens:\n'
+                                      '    max-spaces-after: 2\n')
 
-        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(new.rules['colons']['max-spaces-before'], 0)
-        self.assertEqual(new.rules['colons']['max-spaces-after'], 1)
-        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
+        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
+        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
 
-        self.assertEqual(len(new.enabled_rules()), 2)
+        self.assertEqual(len(c.enabled_rules(None)), 2)
+
+    def test_extend_recursive_default_values(self):
+        with tempfile.NamedTemporaryFile('w') as f:
+            f.write('rules:\n'
+                    '  braces:\n'
+                    '    max-spaces-inside: 1248\n')
+            f.flush()
+            c = config.YamlLintConfig('extends: ' + f.name + '\n'
+                                      'rules:\n'
+                                      '  braces:\n'
+                                      '    min-spaces-inside-empty: 2357\n')
+
+        self.assertEqual(c.rules['braces']['min-spaces-inside'], 0)
+        self.assertEqual(c.rules['braces']['max-spaces-inside'], 1248)
+        self.assertEqual(c.rules['braces']['min-spaces-inside-empty'], 2357)
+        self.assertEqual(c.rules['braces']['max-spaces-inside-empty'], -1)
+
+        with tempfile.NamedTemporaryFile('w') as f:
+            f.write('rules:\n'
+                    '  colons:\n'
+                    '    max-spaces-before: 1337\n')
+            f.flush()
+            c = config.YamlLintConfig('extends: ' + f.name + '\n'
+                                      'rules:\n'
+                                      '  colons: enable\n')
+
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 1337)
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
+
+        with tempfile.NamedTemporaryFile('w') as f1, \
+                tempfile.NamedTemporaryFile('w') as f2:
+            f1.write('rules:\n'
+                     '  colons:\n'
+                     '    max-spaces-before: 1337\n')
+            f1.flush()
+            f2.write('extends: ' + f1.name + '\n'
+                     'rules:\n'
+                     '  colons: disable\n')
+            f2.flush()
+            c = config.YamlLintConfig('extends: ' + f2.name + '\n'
+                                      'rules:\n'
+                                      '  colons: enable\n')
+
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
 
 
 class ExtendedLibraryConfigTestCase(unittest.TestCase):
@@ -257,6 +348,9 @@ class ExtendedLibraryConfigTestCase(unittest.TestCase):
         self.assertEqual(sorted(new.rules.keys()), sorted(old.rules.keys()))
         for rule in new.rules:
             self.assertEqual(new.rules[rule], old.rules[rule])
+        self.assertEqual(new.rules['empty-lines']['max'], 42)
+        self.assertEqual(new.rules['empty-lines']['max-start'], 43)
+        self.assertEqual(new.rules['empty-lines']['max-end'], 44)
 
     def test_extend_config_override_rule_partly(self):
         old = config.YamlLintConfig('extends: default')
@@ -270,3 +364,96 @@ class ExtendedLibraryConfigTestCase(unittest.TestCase):
         self.assertEqual(sorted(new.rules.keys()), sorted(old.rules.keys()))
         for rule in new.rules:
             self.assertEqual(new.rules[rule], old.rules[rule])
+        self.assertEqual(new.rules['empty-lines']['max'], 2)
+        self.assertEqual(new.rules['empty-lines']['max-start'], 42)
+        self.assertEqual(new.rules['empty-lines']['max-end'], 0)
+
+
+class IgnorePathConfigTestCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super(IgnorePathConfigTestCase, cls).setUpClass()
+
+        bad_yaml = ('---\n'
+                    '- key: val1\n'
+                    '  key: val2\n'
+                    '- trailing space \n'
+                    '-    lonely hyphen\n')
+
+        cls.wd = build_temp_workspace({
+            'bin/file.lint-me-anyway.yaml': bad_yaml,
+            'bin/file.yaml': bad_yaml,
+            'file-at-root.yaml': bad_yaml,
+            'file.dont-lint-me.yaml': bad_yaml,
+            'ign-dup/file.yaml': bad_yaml,
+            'ign-dup/sub/dir/file.yaml': bad_yaml,
+            'ign-trail/file.yaml': bad_yaml,
+            'include/ign-dup/sub/dir/file.yaml': bad_yaml,
+            's/s/ign-trail/file.yaml': bad_yaml,
+            's/s/ign-trail/s/s/file.yaml': bad_yaml,
+            's/s/ign-trail/s/s/file2.lint-me-anyway.yaml': bad_yaml,
+
+            '.yamllint': 'ignore: |\n'
+                         '  *.dont-lint-me.yaml\n'
+                         '  /bin/\n'
+                         '  !/bin/*.lint-me-anyway.yaml\n'
+                         '\n'
+                         'extends: default\n'
+                         '\n'
+                         'rules:\n'
+                         '  key-duplicates:\n'
+                         '    ignore: |\n'
+                         '      /ign-dup\n'
+                         '  trailing-spaces:\n'
+                         '    ignore: |\n'
+                         '      ign-trail\n'
+                         '      !*.lint-me-anyway.yaml\n',
+        })
+
+        cls.backup_wd = os.getcwd()
+        os.chdir(cls.wd)
+
+    @classmethod
+    def tearDownClass(cls):
+        super(IgnorePathConfigTestCase, cls).tearDownClass()
+
+        os.chdir(cls.backup_wd)
+
+        shutil.rmtree(cls.wd)
+
+    def test_run_with_ignored_path(self):
+        sys.stdout = StringIO()
+        with self.assertRaises(SystemExit):
+            cli.run(('-f', 'parsable', '.'))
+
+        out = sys.stdout.getvalue()
+        out = '\n'.join(sorted(out.splitlines()))
+
+        keydup = '[error] duplication of key "key" in mapping (key-duplicates)'
+        trailing = '[error] trailing spaces (trailing-spaces)'
+        hyphen = '[error] too many spaces after hyphen (hyphens)'
+
+        self.assertEqual(out, '\n'.join((
+            './bin/file.lint-me-anyway.yaml:3:3: ' + keydup,
+            './bin/file.lint-me-anyway.yaml:4:17: ' + trailing,
+            './bin/file.lint-me-anyway.yaml:5:5: ' + hyphen,
+            './file-at-root.yaml:3:3: ' + keydup,
+            './file-at-root.yaml:4:17: ' + trailing,
+            './file-at-root.yaml:5:5: ' + hyphen,
+            './ign-dup/file.yaml:4:17: ' + trailing,
+            './ign-dup/file.yaml:5:5: ' + hyphen,
+            './ign-dup/sub/dir/file.yaml:4:17: ' + trailing,
+            './ign-dup/sub/dir/file.yaml:5:5: ' + hyphen,
+            './ign-trail/file.yaml:3:3: ' + keydup,
+            './ign-trail/file.yaml:5:5: ' + hyphen,
+            './include/ign-dup/sub/dir/file.yaml:3:3: ' + keydup,
+            './include/ign-dup/sub/dir/file.yaml:4:17: ' + trailing,
+            './include/ign-dup/sub/dir/file.yaml:5:5: ' + hyphen,
+            './s/s/ign-trail/file.yaml:3:3: ' + keydup,
+            './s/s/ign-trail/file.yaml:5:5: ' + hyphen,
+            './s/s/ign-trail/s/s/file.yaml:3:3: ' + keydup,
+            './s/s/ign-trail/s/s/file.yaml:5:5: ' + hyphen,
+            './s/s/ign-trail/s/s/file2.lint-me-anyway.yaml:3:3: ' + keydup,
+            './s/s/ign-trail/s/s/file2.lint-me-anyway.yaml:4:17: ' + trailing,
+            './s/s/ign-trail/s/s/file2.lint-me-anyway.yaml:5:5: ' + hyphen,
+        )))

tests/test_linter.py

@@ -15,7 +15,6 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import io
-
 import unittest
 
 from yamllint.config import YamlLintConfig

tests/test_module.py

@@ -18,9 +18,13 @@ import os
 import shutil
 import subprocess
 import tempfile
+import sys
 import unittest
 
 
+PYTHON = sys.executable or 'python'
+
+
 class ModuleTestCase(unittest.TestCase):
     def setUp(self):
         self.wd = tempfile.mkdtemp(prefix='yamllint-tests-')
@@ -40,7 +44,7 @@ class ModuleTestCase(unittest.TestCase):
 
     def test_run_module_no_args(self):
         with self.assertRaises(subprocess.CalledProcessError) as ctx:
-            subprocess.check_output(['python', '-m', 'yamllint'],
+            subprocess.check_output([PYTHON, '-m', 'yamllint'],
                                     stderr=subprocess.STDOUT)
         self.assertEqual(ctx.exception.returncode, 2)
         self.assertRegexpMatches(ctx.exception.output.decode(),
@@ -48,7 +52,7 @@ class ModuleTestCase(unittest.TestCase):
 
     def test_run_module_on_bad_dir(self):
         with self.assertRaises(subprocess.CalledProcessError) as ctx:
-            subprocess.check_output(['python', '-m', 'yamllint',
+            subprocess.check_output([PYTHON, '-m', 'yamllint',
                                      '/does/not/exist'],
                                     stderr=subprocess.STDOUT)
         self.assertRegexpMatches(ctx.exception.output.decode(),
@@ -56,7 +60,7 @@ class ModuleTestCase(unittest.TestCase):
 
     def test_run_module_on_file(self):
         out = subprocess.check_output(
-            ['python', '-m', 'yamllint', os.path.join(self.wd, 'warn.yaml')])
+            [PYTHON, '-m', 'yamllint', os.path.join(self.wd, 'warn.yaml')])
         lines = out.decode().splitlines()
         self.assertIn('/warn.yaml', lines[0])
         self.assertEqual('\n'.join(lines[1:]),
@@ -65,7 +69,7 @@ class ModuleTestCase(unittest.TestCase):
 
     def test_run_module_on_dir(self):
         with self.assertRaises(subprocess.CalledProcessError) as ctx:
-            subprocess.check_output(['python', '-m', 'yamllint', self.wd])
+            subprocess.check_output([PYTHON, '-m', 'yamllint', self.wd])
         self.assertEqual(ctx.exception.returncode, 1)
 
         files = ctx.exception.output.decode().split('\n\n')

tests/test_parser.py

@@ -65,12 +65,12 @@ class ParserTestCase(unittest.TestCase):
     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.assertIsNone(e[0].prev)
         self.assertIsInstance(e[0].curr, yaml.Token)
         self.assertIsInstance(e[0].next, yaml.Token)
         self.assertEqual(e[1].prev, e[0].curr)
         self.assertEqual(e[1].curr, e[0].next)
-        self.assertEqual(e[1].next, None)
+        self.assertIsNone(e[1].next)
 
         e = list(token_or_comment_generator('---\n'
                                             'k: v\n'))

tests/test_spec_examples.py

@@ -54,8 +54,8 @@ conf_general = ('document-start: disable\n'
                 'braces: {min-spaces-inside: 1, max-spaces-inside: 1}\n'
                 'brackets: {min-spaces-inside: 1, max-spaces-inside: 1}\n')
 conf_overrides = {
-    'example-2.2': ('colons: {max-spaces-after: 2}\n'),
-    'example-2.4': ('colons: {max-spaces-after: 3}\n'),
+    'example-2.2': 'colons: {max-spaces-after: 2}\n',
+    'example-2.4': 'colons: {max-spaces-after: 3}\n',
     'example-2.5': ('empty-lines: {max-end: 2}\n'
                     'brackets: {min-spaces-inside: 0, max-spaces-inside: 2}\n'
                     'commas: {max-spaces-before: -1}\n'),
@@ -63,65 +63,65 @@ conf_overrides = {
                     'indentation: disable\n'),
     'example-2.12': ('empty-lines: {max-end: 1}\n'
                      'colons: {max-spaces-before: -1}\n'),
-    'example-2.16': ('empty-lines: {max-end: 1}\n'),
-    'example-2.18': ('empty-lines: {max-end: 1}\n'),
-    'example-2.19': ('empty-lines: {max-end: 1}\n'),
-    'example-2.28': ('empty-lines: {max-end: 3}\n'),
+    'example-2.16': 'empty-lines: {max-end: 1}\n',
+    'example-2.18': 'empty-lines: {max-end: 1}\n',
+    'example-2.19': 'empty-lines: {max-end: 1}\n',
+    'example-2.28': 'empty-lines: {max-end: 3}\n',
     'example-5.3': ('indentation: {indent-sequences: false}\n'
                     'colons: {max-spaces-before: 1}\n'),
-    'example-6.4': ('trailing-spaces: disable\n'),
-    'example-6.5': ('trailing-spaces: disable\n'),
-    'example-6.6': ('trailing-spaces: disable\n'),
-    'example-6.7': ('trailing-spaces: disable\n'),
-    'example-6.8': ('trailing-spaces: disable\n'),
+    'example-6.4': 'trailing-spaces: disable\n',
+    'example-6.5': 'trailing-spaces: disable\n',
+    'example-6.6': 'trailing-spaces: disable\n',
+    'example-6.7': 'trailing-spaces: disable\n',
+    'example-6.8': 'trailing-spaces: disable\n',
     'example-6.10': ('empty-lines: {max-end: 2}\n'
                      'trailing-spaces: disable\n'
                      'comments-indentation: disable\n'),
     'example-6.11': ('empty-lines: {max-end: 1}\n'
                      'comments-indentation: disable\n'),
-    'example-6.13': ('comments-indentation: disable\n'),
-    'example-6.14': ('comments-indentation: disable\n'),
-    'example-6.23': ('colons: {max-spaces-before: 1}\n'),
+    'example-6.13': 'comments-indentation: disable\n',
+    'example-6.14': 'comments-indentation: disable\n',
+    'example-6.23': 'colons: {max-spaces-before: 1}\n',
     'example-7.4': ('colons: {max-spaces-before: 1}\n'
                     'indentation: disable\n'),
-    'example-7.5': ('trailing-spaces: disable\n'),
-    'example-7.6': ('trailing-spaces: disable\n'),
-    'example-7.7': ('indentation: disable\n'),
+    'example-7.5': 'trailing-spaces: disable\n',
+    'example-7.6': 'trailing-spaces: disable\n',
+    'example-7.7': 'indentation: disable\n',
     'example-7.8': ('colons: {max-spaces-before: 1}\n'
                     'indentation: disable\n'),
-    'example-7.9': ('trailing-spaces: disable\n'),
+    'example-7.9': 'trailing-spaces: disable\n',
     'example-7.11': ('colons: {max-spaces-before: 1}\n'
                      'indentation: disable\n'),
     'example-7.13': ('brackets: {min-spaces-inside: 0, max-spaces-inside: 1}\n'
                      'commas: {max-spaces-before: 1, min-spaces-after: 0}\n'),
-    'example-7.14': ('indentation: disable\n'),
+    'example-7.14': 'indentation: disable\n',
     'example-7.15': ('braces: {min-spaces-inside: 0, max-spaces-inside: 1}\n'
                      'commas: {max-spaces-before: 1, min-spaces-after: 0}\n'
                      'colons: {max-spaces-before: 1}\n'),
-    'example-7.16': ('indentation: disable\n'),
-    'example-7.17': ('indentation: disable\n'),
-    'example-7.18': ('indentation: disable\n'),
-    'example-7.19': ('indentation: disable\n'),
+    'example-7.16': 'indentation: disable\n',
+    'example-7.17': 'indentation: disable\n',
+    'example-7.18': 'indentation: disable\n',
+    'example-7.19': 'indentation: disable\n',
     'example-7.20': ('colons: {max-spaces-before: 1}\n'
                      'indentation: disable\n'),
-    'example-8.1': ('empty-lines: {max-end: 1}\n'),
-    'example-8.2': ('trailing-spaces: disable\n'),
+    'example-8.1': 'empty-lines: {max-end: 1}\n',
+    'example-8.2': 'trailing-spaces: disable\n',
     'example-8.5': ('comments-indentation: disable\n'
                     'trailing-spaces: disable\n'),
-    'example-8.6': ('empty-lines: {max-end: 1}\n'),
-    'example-8.7': ('empty-lines: {max-end: 1}\n'),
-    'example-8.8': ('trailing-spaces: disable\n'),
-    'example-8.9': ('empty-lines: {max-end: 1}\n'),
-    'example-8.14': ('colons: {max-spaces-before: 1}\n'),
-    'example-8.16': ('indentation: {spaces: 1}\n'),
-    'example-8.17': ('indentation: disable\n'),
+    'example-8.6': 'empty-lines: {max-end: 1}\n',
+    'example-8.7': 'empty-lines: {max-end: 1}\n',
+    'example-8.8': 'trailing-spaces: disable\n',
+    'example-8.9': 'empty-lines: {max-end: 1}\n',
+    'example-8.14': 'colons: {max-spaces-before: 1}\n',
+    'example-8.16': 'indentation: {spaces: 1}\n',
+    'example-8.17': 'indentation: disable\n',
     'example-8.20': ('indentation: {indent-sequences: false}\n'
                      'colons: {max-spaces-before: 1}\n'),
-    'example-8.22': ('indentation: disable\n'),
-    'example-10.1': ('colons: {max-spaces-before: 2}\n'),
-    'example-10.2': ('indentation: {indent-sequences: false}\n'),
-    'example-10.8': ('truthy: disable\n'),
-    'example-10.9': ('truthy: disable\n'),
+    'example-8.22': 'indentation: disable\n',
+    'example-10.1': 'colons: {max-spaces-before: 2}\n',
+    'example-10.2': 'indentation: {indent-sequences: false}\n',
+    'example-10.8': 'truthy: disable\n',
+    'example-10.9': 'truthy: disable\n',
 }
 
 files = os.listdir(os.path.join(os.path.dirname(os.path.realpath(__file__)),

yamllint/__init__.py

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

yamllint/cli.py

@@ -15,9 +15,10 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import print_function
-import os.path
-import sys
 
+import os
+import sys
+import platform
 import argparse
 
 from yamllint import APP_DESCRIPTION, APP_NAME, APP_VERSION
@@ -37,6 +38,15 @@ def find_files_recursively(items):
             yield item
 
 
+def supports_color():
+    supported_platform = not (platform.system() == 'Windows' and not
+                              ('ANSICON' in os.environ or
+                               ('TERM' in os.environ and
+                                os.environ['TERM'] == 'ANSI')))
+    return (supported_platform and
+            hasattr(sys.stdout, 'isatty') and sys.stdout.isatty())
+
+
 class Format(object):
     @staticmethod
     def parsable(problem, filename):
@@ -78,30 +88,27 @@ 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-file', dest='config_file',
-                        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)')
+    config_group = parser.add_mutually_exclusive_group()
+    config_group.add_argument('-c', '--config-file', dest='config_file',
+                              action='store',
+                              help='path to a custom configuration')
+    config_group.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')
+                        choices=('parsable', 'standard', 'colored', 'auto'),
+                        default='auto', help='format for parsing output')
     parser.add_argument('-s', '--strict',
                         action='store_true',
                         help='return non-zero exit code on warnings '
                              'as well as errors')
     parser.add_argument('-v', '--version', action='version',
-                        version='%s %s' % (APP_NAME, APP_VERSION))
+                        version='{} {}'.format(APP_NAME, APP_VERSION))
 
     # TODO: read from stdin when no filename?
 
     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
     if 'XDG_CONFIG_HOME' in os.environ:
         user_global_config = os.path.join(
@@ -129,13 +136,15 @@ def run(argv=None):
     max_level = 0
 
     for file in find_files_recursively(args.files):
+        filepath = file[2:] if file.startswith('./') else file
         try:
             first = True
             with open(file) as f:
-                for problem in linter.run(f, conf):
+                for problem in linter.run(f, conf, filepath):
                     if args.format == 'parsable':
                         print(Format.parsable(problem, file))
-                    elif sys.stdout.isatty():
+                    elif args.format == 'colored' or \
+                            (args.format == 'auto' and supports_color()):
                         if first:
                             print('\033[4m%s\033[0m' % file)
                             first = False

yamllint/conf/default.yaml

@@ -1,51 +1,28 @@
 ---
 
 rules:
-  braces:
-    min-spaces-inside: 0
-    max-spaces-inside: 0
-    min-spaces-inside-empty: -1
-    max-spaces-inside-empty: -1
-  brackets:
-    min-spaces-inside: 0
-    max-spaces-inside: 0
-    min-spaces-inside-empty: -1
-    max-spaces-inside-empty: -1
-  colons:
-    max-spaces-before: 0
-    max-spaces-after: 1
-  commas:
-    max-spaces-before: 0
-    min-spaces-after: 1
-    max-spaces-after: 1
+  braces: enable
+  brackets: enable
+  colons: enable
+  commas: enable
   comments:
     level: warning
-    require-starting-space: true
-    min-spaces-from-content: 2
   comments-indentation:
     level: warning
   document-end: disable
   document-start:
     level: warning
-    present: true
-  empty-lines:
-    max: 2
-    max-start: 0
-    max-end: 0
-  hyphens:
-    max-spaces-after: 1
-  indentation:
-    spaces: consistent
-    indent-sequences: true
-    check-multi-line-strings: false
+  empty-lines: enable
+  empty-values: enable
+  hyphens: enable
+  indentation: enable
   key-duplicates: enable
-  line-length:
-    max: 80
-    allow-non-breakable-words: true
-    allow-non-breakable-inline-mappings: false
+  key-ordering: disable
+  line-length: enable
   new-line-at-end-of-file: enable
-  new-lines:
-    type: unix
+  new-lines: enable
+  octal-values: enable
+  quoted-strings: disable
   trailing-spaces: enable
   truthy:
     level: warning

yamllint/config.py

@@ -16,6 +16,7 @@
 
 import os.path
 
+import pathspec
 import yaml
 
 import yamllint.rules
@@ -29,6 +30,8 @@ class YamlLintConfig(object):
     def __init__(self, content=None, file=None):
         assert (content is None) ^ (file is None)
 
+        self.ignore = None
+
         if file is not None:
             with open(file) as f:
                 content = f.read()
@@ -36,15 +39,20 @@ class YamlLintConfig(object):
         self.parse(content)
         self.validate()
 
-    def enabled_rules(self):
+    def is_file_ignored(self, filepath):
+        return self.ignore and self.ignore.match_file(filepath)
+
+    def enabled_rules(self, filepath):
         return [yamllint.rules.get(id) for id, val in self.rules.items()
-                if val is not False]
+                if val is not False and (
+                    filepath is None or 'ignore' not in val or
+                    not val['ignore'].match_file(filepath))]
 
     def extend(self, base_config):
         assert isinstance(base_config, YamlLintConfig)
 
         for rule in self.rules:
-            if (type(self.rules[rule]) == dict and
+            if (isinstance(self.rules[rule], dict) and
                     rule in base_config.rules and
                     base_config.rules[rule] is not False):
                 base_config.rules[rule].update(self.rules[rule])
@@ -53,16 +61,24 @@ class YamlLintConfig(object):
 
         self.rules = base_config.rules
 
+        if base_config.ignore is not None:
+            self.ignore = base_config.ignore
+
     def parse(self, raw_content):
         try:
             conf = yaml.safe_load(raw_content)
         except Exception as e:
             raise YamlLintConfigError('invalid config: %s' % e)
 
-        if type(conf) != dict:
+        if not isinstance(conf, dict):
             raise YamlLintConfigError('invalid config: not a dict')
 
         self.rules = conf.get('rules', {})
+        for rule in self.rules:
+            if self.rules[rule] == 'enable':
+                self.rules[rule] = {}
+            elif self.rules[rule] == 'disable':
+                self.rules[rule] = False
 
         # Does this conf override another conf that we need to load?
         if 'extends' in conf:
@@ -73,6 +89,13 @@ class YamlLintConfig(object):
             except Exception as e:
                 raise YamlLintConfigError('invalid config: %s' % e)
 
+        if 'ignore' in conf:
+            if not isinstance(conf['ignore'], str):
+                raise YamlLintConfigError(
+                    'invalid config: ignore should contain file patterns')
+            self.ignore = pathspec.PathSpec.from_lines(
+                'gitwildmatch', conf['ignore'].splitlines())
+
     def validate(self):
         for id in self.rules:
             try:
@@ -84,12 +107,18 @@ class YamlLintConfig(object):
 
 
 def validate_rule_conf(rule, conf):
-    if conf is False or conf == 'disable':
+    if conf is False:  # disable
         return False
-    elif conf == 'enable':
-        conf = {}
 
-    if type(conf) == dict:
+    if isinstance(conf, dict):
+        if ('ignore' in conf and
+                not isinstance(conf['ignore'], pathspec.pathspec.PathSpec)):
+            if not isinstance(conf['ignore'], str):
+                raise YamlLintConfigError(
+                    'invalid config: ignore should contain file patterns')
+            conf['ignore'] = pathspec.PathSpec.from_lines(
+                'gitwildmatch', conf['ignore'].splitlines())
+
         if 'level' not in conf:
             conf['level'] = 'error'
         elif conf['level'] not in ('error', 'warning'):
@@ -97,29 +126,28 @@ def validate_rule_conf(rule, conf):
                 'invalid config: level should be "error" or "warning"')
 
         options = getattr(rule, 'CONF', {})
+        options_default = getattr(rule, 'DEFAULT', {})
         for optkey in conf:
-            if optkey == 'level':
+            if optkey in ('ignore', 'level'):
                 continue
             if optkey not in options:
                 raise YamlLintConfigError(
                     'invalid config: unknown option "%s" for rule "%s"' %
                     (optkey, rule.ID))
-            if type(options[optkey]) == tuple:
+            if isinstance(options[optkey], tuple):
                 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]))
             else:
-                if type(conf[optkey]) != options[optkey]:
+                if not isinstance(conf[optkey], options[optkey]):
                     raise YamlLintConfigError(
                         'invalid config: option "%s" of "%s" should be %s'
                         % (optkey, rule.ID, options[optkey].__name__))
         for optkey in options:
             if optkey not in conf:
-                raise YamlLintConfigError(
-                    'invalid config: missing option "%s" for rule "%s"' %
-                    (optkey, rule.ID))
+                conf[optkey] = options_default[optkey]
     else:
         raise YamlLintConfigError(('invalid config: rule "%s": should be '
                                    'either "enable", "disable" or a dict')

yamllint/linter.py

@@ -47,7 +47,7 @@ class LintProblem(object):
     @property
     def message(self):
         if self.rule is not None:
-            return '%s (%s)' % (self.desc, self.rule)
+            return '{} ({})'.format(self.desc, self.rule)
         return self.desc
 
     def __eq__(self, other):
@@ -63,8 +63,8 @@ class LintProblem(object):
         return '%d:%d: %s' % (self.line, self.column, self.message)
 
 
-def get_cosmetic_problems(buffer, conf):
-    rules = conf.enabled_rules()
+def get_cosmetic_problems(buffer, conf, filepath):
+    rules = conf.enabled_rules(filepath)
 
     # Split token rules from line rules
     token_rules = [r for r in rules if r.TYPE == 'token']
@@ -75,10 +75,10 @@ def get_cosmetic_problems(buffer, conf):
     for rule in token_rules:
         context[rule.ID] = {}
 
-    class DisableDirective():
+    class DisableDirective:
         def __init__(self):
             self.rules = set()
-            self.all_rules = set([r.ID for r in rules])
+            self.all_rules = {r.ID for r in rules}
 
         def process_comment(self, comment):
             try:
@@ -185,7 +185,7 @@ def get_syntax_error(buffer):
         return problem
 
 
-def _run(buffer, conf):
+def _run(buffer, conf, filepath):
     assert hasattr(buffer, '__getitem__'), \
         '_run() argument must be a buffer, not a stream'
 
@@ -193,7 +193,7 @@ def _run(buffer, conf):
     # right line
     syntax_error = get_syntax_error(buffer)
 
-    for problem in get_cosmetic_problems(buffer, conf):
+    for problem in get_cosmetic_problems(buffer, conf, filepath):
         # Insert the syntax error (if any) at the right place...
         if (syntax_error and syntax_error.line <= problem.line and
                 syntax_error.column <= problem.column):
@@ -215,7 +215,7 @@ def _run(buffer, conf):
         yield syntax_error
 
 
-def run(input, conf):
+def run(input, conf, filepath=None):
     """Lints a YAML source.
 
     Returns a generator of LintProblem objects.
@@ -223,11 +223,14 @@ def run(input, conf):
     :param input: buffer, string or stream to read from
     :param conf: yamllint configuration object
     """
-    if type(input) in (type(b''), type(u'')):  # compat with Python 2 & 3
-        return _run(input, conf)
+    if conf.is_file_ignored(filepath):
+        return ()
+
+    if isinstance(input, (type(b''), type(u''))):  # compat with Python 2 & 3
+        return _run(input, conf, filepath)
     elif hasattr(input, 'read'):  # Python 2's file or Python 3's io.IOBase
         # We need to have everything in memory to parse correctly
         content = input.read()
-        return _run(content, conf)
+        return _run(content, conf, filepath)
     else:
         raise TypeError('input should be a string or a stream')

yamllint/parser.py

@@ -125,7 +125,8 @@ def token_or_comment_generator(buffer):
         curr = yaml_loader.get_token()
         while curr is not None:
             next = yaml_loader.get_token()
-            nextnext = yaml_loader.peek_token()
+            nextnext = (yaml_loader.peek_token()
+                        if yaml_loader.check_token() else None)
 
             yield Token(curr.start_mark.line + 1, curr, prev, next, nextnext)
 

yamllint/rules/__init__.py

@@ -24,12 +24,16 @@ from yamllint.rules import (
     document_end,
     document_start,
     empty_lines,
+    empty_values,
     hyphens,
     indentation,
     key_duplicates,
+    key_ordering,
     line_length,
     new_line_at_end_of_file,
     new_lines,
+    octal_values,
+    quoted_strings,
     trailing_spaces,
     truthy,
 )
@@ -44,12 +48,16 @@ _RULES = {
     document_end.ID: document_end,
     document_start.ID: document_start,
     empty_lines.ID: empty_lines,
+    empty_values.ID: empty_values,
     hyphens.ID: hyphens,
     indentation.ID: indentation,
     key_duplicates.ID: key_duplicates,
+    key_ordering.ID: key_ordering,
     line_length.ID: line_length,
     new_line_at_end_of_file.ID: new_line_at_end_of_file,
     new_lines.ID: new_lines,
+    octal_values.ID: octal_values,
+    quoted_strings.ID: quoted_strings,
     trailing_spaces.ID: trailing_spaces,
     truthy.ID: truthy,
 }

yamllint/rules/braces.py

@@ -101,6 +101,10 @@ CONF = {'min-spaces-inside': int,
         'max-spaces-inside': int,
         'min-spaces-inside-empty': int,
         'max-spaces-inside-empty': int}
+DEFAULT = {'min-spaces-inside': 0,
+           'max-spaces-inside': 0,
+           'min-spaces-inside-empty': -1,
+           'max-spaces-inside-empty': -1}
 
 
 def check(conf, token, prev, next, nextnext, context):

yamllint/rules/brackets.py

@@ -102,6 +102,10 @@ CONF = {'min-spaces-inside': int,
         'max-spaces-inside': int,
         'min-spaces-inside-empty': int,
         'max-spaces-inside-empty': int}
+DEFAULT = {'min-spaces-inside': 0,
+           'max-spaces-inside': 0,
+           'min-spaces-inside-empty': -1,
+           'max-spaces-inside-empty': -1}
 
 
 def check(conf, token, prev, next, nextnext, context):

yamllint/rules/colons.py

@@ -79,6 +79,8 @@ ID = 'colons'
 TYPE = 'token'
 CONF = {'max-spaces-before': int,
         'max-spaces-after': int}
+DEFAULT = {'max-spaces-before': 0,
+           'max-spaces-after': 1}
 
 
 def check(conf, token, prev, next, nextnext, context):

yamllint/rules/commas.py

@@ -103,6 +103,9 @@ TYPE = 'token'
 CONF = {'max-spaces-before': int,
         'min-spaces-after': int,
         'max-spaces-after': int}
+DEFAULT = {'max-spaces-before': 0,
+           'min-spaces-after': 1,
+           'max-spaces-after': 1}
 
 
 def check(conf, token, prev, next, nextnext, context):

yamllint/rules/comments.py

@@ -21,6 +21,9 @@ Use this rule to control the position and formatting of comments.
 
 * Use ``require-starting-space`` to require a space character right after the
   ``#``. Set to ``true`` to enable, ``false`` to disable.
+* Use ``ignore-shebangs`` to ignore a
+  `shebang <https://en.wikipedia.org/wiki/Shebang_(Unix)>`_ at the beginning of
+  the file when ``require-starting-space`` is set.
 * ``min-spaces-from-content`` is used to visually separate inline comments from
   content. It defines the minimal required number of spaces between a comment
   and its preceding content.
@@ -61,13 +64,19 @@ Use this rule to control the position and formatting of comments.
 """
 
 
+import re
+
 from yamllint.linter import LintProblem
 
 
 ID = 'comments'
 TYPE = 'comment'
 CONF = {'require-starting-space': bool,
+        'ignore-shebangs': bool,
         'min-spaces-from-content': int}
+DEFAULT = {'require-starting-space': True,
+           'ignore-shebangs': True,
+           'min-spaces-from-content': 2}
 
 
 def check(conf, comment):
@@ -82,8 +91,14 @@ def check(conf, comment):
         while (comment.buffer[text_start] == '#' and
                text_start < len(comment.buffer)):
             text_start += 1
-        if (text_start < len(comment.buffer) and
-                comment.buffer[text_start] not in (' ', '\n', '\0')):
-            yield LintProblem(comment.line_no,
-                              comment.column_no + text_start - comment.pointer,
-                              'missing starting space in comment')
+        if text_start < len(comment.buffer):
+            if (conf['ignore-shebangs'] and
+                    comment.line_no == 1 and
+                    comment.column_no == 1 and
+                    re.match(r'^!\S', comment.buffer[text_start:])):
+                return
+            elif comment.buffer[text_start] not in (' ', '\n', '\0'):
+                column = comment.column_no + text_start - comment.pointer
+                yield LintProblem(comment.line_no,
+                                  column,
+                                  'missing starting space in comment')

yamllint/rules/document_end.py

@@ -82,18 +82,21 @@ from yamllint.linter import LintProblem
 ID = 'document-end'
 TYPE = 'token'
 CONF = {'present': bool}
+DEFAULT = {'present': True}
 
 
 def check(conf, token, prev, next, nextnext, context):
     if conf['present']:
-        if (isinstance(token, yaml.StreamEndToken) and
-                not (isinstance(prev, yaml.DocumentEndToken) or
-                     isinstance(prev, yaml.StreamStartToken))):
+        is_stream_end = isinstance(token, yaml.StreamEndToken)
+        is_start = isinstance(token, yaml.DocumentStartToken)
+        prev_is_end_or_stream_start = isinstance(
+            prev, (yaml.DocumentEndToken, yaml.StreamStartToken)
+        )
+
+        if is_stream_end and not prev_is_end_or_stream_start:
             yield LintProblem(token.start_mark.line, 1,
                               'missing document end "..."')
-        elif (isinstance(token, yaml.DocumentStartToken) and
-                not (isinstance(prev, yaml.DocumentEndToken) or
-                     isinstance(prev, yaml.StreamStartToken))):
+        elif is_start and not prev_is_end_or_stream_start:
             yield LintProblem(token.start_mark.line + 1, 1,
                               'missing document end "..."')
 

yamllint/rules/document_start.py

@@ -72,6 +72,7 @@ from yamllint.linter import LintProblem
 ID = 'document-start'
 TYPE = 'token'
 CONF = {'present': bool}
+DEFAULT = {'present': True}
 
 
 def check(conf, token, prev, next, nextnext, context):

yamllint/rules/empty_lines.py

@@ -58,6 +58,9 @@ TYPE = 'line'
 CONF = {'max': int,
         'max-start': int,
         'max-end': int}
+DEFAULT = {'max': 2,
+           'max-start': 0,
+           'max-end': 0}
 
 
 def check(conf, line):

yamllint/rules/empty_values.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 Greg Dubicki
+#
+# 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/>.
+
+"""
+Use this rule to prevent nodes with empty content, that implicitly result in
+``null`` values.
+
+.. rubric:: Options
+
+* Use ``forbid-in-block-mappings`` to prevent empty values in block mappings.
+* Use ``forbid-in-flow-mappings`` to prevent empty values in flow mappings.
+
+.. rubric:: Examples
+
+#. With ``empty-values: {forbid-in-block-mappings: true}``
+
+   the following code snippets would **PASS**:
+   ::
+
+    some-mapping:
+      sub-element: correctly indented
+
+   ::
+
+    explicitly-null: null
+
+   the following code snippets would **FAIL**:
+   ::
+
+    some-mapping:
+    sub-element: incorrectly indented
+
+   ::
+
+    implicitly-null:
+
+#. With ``empty-values: {forbid-in-flow-mappings: true}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    {prop: null}
+    {a: 1, b: 2, c: 3}
+
+   the following code snippets would **FAIL**:
+   ::
+
+    {prop: }
+
+   ::
+
+    {a: 1, b:, c: 3}
+
+"""
+
+import yaml
+
+from yamllint.linter import LintProblem
+
+
+ID = 'empty-values'
+TYPE = 'token'
+CONF = {'forbid-in-block-mappings': bool,
+        'forbid-in-flow-mappings': bool}
+DEFAULT = {'forbid-in-block-mappings': False,
+           'forbid-in-flow-mappings': False}
+
+
+def check(conf, token, prev, next, nextnext, context):
+
+    if conf['forbid-in-block-mappings']:
+        if isinstance(token, yaml.ValueToken) and isinstance(next, (
+                yaml.KeyToken, yaml.BlockEndToken)):
+            yield LintProblem(token.start_mark.line + 1,
+                              token.end_mark.column + 1,
+                              'empty value in block mapping')
+
+    if conf['forbid-in-flow-mappings']:
+        if isinstance(token, yaml.ValueToken) and isinstance(next, (
+                yaml.FlowEntryToken, yaml.FlowMappingEndToken)):
+            yield LintProblem(token.start_mark.line + 1,
+                              token.end_mark.column + 1,
+                              'empty value in flow mapping')

yamllint/rules/hyphens.py

@@ -76,6 +76,7 @@ from yamllint.rules.common import spaces_after
 ID = 'hyphens'
 TYPE = 'token'
 CONF = {'max-spaces-after': int}
+DEFAULT = {'max-spaces-after': 1}
 
 
 def check(conf, token, prev, next, nextnext, context):

yamllint/rules/indentation.py

@@ -201,6 +201,9 @@ TYPE = 'token'
 CONF = {'spaces': (int, 'consistent'),
         'indent-sequences': (bool, 'whatever', 'consistent'),
         'check-multi-line-strings': bool}
+DEFAULT = {'spaces': 'consistent',
+           'indent-sequences': True,
+           'check-multi-line-strings': False}
 
 ROOT, B_MAP, F_MAP, B_SEQ, F_SEQ, B_ENT, KEY, VAL = range(8)
 labels = ('ROOT', 'B_MAP', 'F_MAP', 'B_SEQ', 'F_SEQ', 'B_ENT', 'KEY', 'VAL')
@@ -224,7 +227,7 @@ def check_scalar_indentation(conf, token, context):
 
     def compute_expected_indent(found_indent):
         def detect_indent(base_indent):
-            if type(context['spaces']) is not int:
+            if not isinstance(context['spaces'], int):
                 context['spaces'] = found_indent - base_indent
             return base_indent + context['spaces']
 
@@ -312,7 +315,7 @@ def _check(conf, token, prev, next, nextnext, context):
                      token.start_mark.line + 1 > context['cur_line'])
 
     def detect_indent(base_indent, next):
-        if type(context['spaces']) is not int:
+        if not isinstance(context['spaces'], int):
             context['spaces'] = next.start_mark.column - base_indent
         return base_indent + context['spaces']
 
@@ -399,6 +402,10 @@ def _check(conf, token, prev, next, nextnext, context):
             #   - item 1
             #   - item 2
             indent = next.start_mark.column
+        elif next.start_mark.column == token.start_mark.column:
+            #   -
+            #   key: value
+            indent = next.start_mark.column
         else:
             #   -
             #     item 1

yamllint/rules/key_duplicates.py

@@ -61,7 +61,6 @@ from yamllint.linter import LintProblem
 
 ID = 'key-duplicates'
 TYPE = 'token'
-CONF = {}
 
 MAP, SEQ = range(2)
 
@@ -91,7 +90,9 @@ def check(conf, token, prev, next, nextnext, context):
         # This check is done because KeyTokens can be found inside flow
         # sequences... strange, but allowed.
         if len(context['stack']) > 0 and context['stack'][-1].type == MAP:
-            if next.value in context['stack'][-1].keys:
+            if (next.value in context['stack'][-1].keys and
+                    # `<<` is "merge key", see http://yaml.org/type/merge.html
+                    next.value != '<<'):
                 yield LintProblem(
                     next.start_mark.line + 1, next.start_mark.column + 1,
                     'duplication of key "%s" in mapping' % next.value)

yamllint/rules/key_ordering.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 Johannes F. Knauf
+#
+# 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/>.
+
+"""
+Use this rule to enforce alphabetical ordering of keys in mappings. The sorting
+order uses the Unicode code point number. As a result, the ordering is
+case-sensitive and not accent-friendly (see examples below).
+
+.. rubric:: Examples
+
+#. With ``key-ordering: {}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    - key 1: v
+      key 2: val
+      key 3: value
+    - {a: 1, b: 2, c: 3}
+    - T-shirt: 1
+      T-shirts: 2
+      t-shirt: 3
+      t-shirts: 4
+    - hair: true
+      hais: true
+      haïr: true
+      haïssable: true
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - key 2: v
+      key 1: val
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - {b: 1, a: 2}
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - T-shirt: 1
+      t-shirt: 2
+      T-shirts: 3
+      t-shirts: 4
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - haïr: true
+      hais: true
+"""
+
+import yaml
+
+from yamllint.linter import LintProblem
+
+
+ID = 'key-ordering'
+TYPE = 'token'
+
+MAP, SEQ = range(2)
+
+
+class Parent(object):
+    def __init__(self, type):
+        self.type = type
+        self.keys = []
+
+
+def check(conf, token, prev, next, nextnext, context):
+    if 'stack' not in context:
+        context['stack'] = []
+
+    if isinstance(token, (yaml.BlockMappingStartToken,
+                          yaml.FlowMappingStartToken)):
+        context['stack'].append(Parent(MAP))
+    elif isinstance(token, (yaml.BlockSequenceStartToken,
+                            yaml.FlowSequenceStartToken)):
+        context['stack'].append(Parent(SEQ))
+    elif isinstance(token, (yaml.BlockEndToken,
+                            yaml.FlowMappingEndToken,
+                            yaml.FlowSequenceEndToken)):
+        context['stack'].pop()
+    elif (isinstance(token, yaml.KeyToken) and
+          isinstance(next, yaml.ScalarToken)):
+        # This check is done because KeyTokens can be found inside flow
+        # sequences... strange, but allowed.
+        if len(context['stack']) > 0 and context['stack'][-1].type == MAP:
+            if any(next.value < key for key in context['stack'][-1].keys):
+                yield LintProblem(
+                    next.start_mark.line + 1, next.start_mark.column + 1,
+                    'wrong ordering of key "%s" in mapping' % next.value)
+            else:
+                context['stack'][-1].keys.append(next.value)

yamllint/rules/line_length.py

@@ -17,6 +17,10 @@
 """
 Use this rule to set a limit to lines length.
 
+Note: with Python 2, the ``line-length`` rule may not work properly with
+unicode characters because of the way strings are represented in bytes. We
+recommend running yamllint with Python 3.
+
 .. rubric:: Options
 
 * ``max`` defines the maximal (inclusive) length of lines.
@@ -98,6 +102,9 @@ TYPE = 'line'
 CONF = {'max': int,
         'allow-non-breakable-words': bool,
         'allow-non-breakable-inline-mappings': bool}
+DEFAULT = {'max': 80,
+           'allow-non-breakable-words': True,
+           'allow-non-breakable-inline-mappings': False}
 
 
 def check_inline_mapping(line):

yamllint/rules/new_lines.py

@@ -30,6 +30,7 @@ from yamllint.linter import LintProblem
 ID = 'new-lines'
 TYPE = 'line'
 CONF = {'type': ('unix', 'dos')}
+DEFAULT = {'type': 'unix'}
 
 
 def check(conf, line):

yamllint/rules/octal_values.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 ScienJus
+#
+# 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/>.
+
+"""
+Use this rule to prevent values with octal numbers. In YAML, numbers that
+start with ``0`` are interpreted as octal, but this is not always wanted.
+For instance ``010`` is the city code of Beijing, and should not be
+converted to ``8``.
+
+.. rubric:: Examples
+
+#. With ``octal-values: {forbid-implicit-octal: true}``
+
+   the following code snippets would **PASS**:
+   ::
+
+    user:
+      city-code: '010'
+
+   the following code snippets would **PASS**:
+   ::
+
+    user:
+      city-code: 010,021
+
+   the following code snippets would **FAIL**:
+   ::
+
+    user:
+      city-code: 010
+
+#. With ``octal-values: {forbid-explicit-octal: true}``
+
+   the following code snippets would **PASS**:
+   ::
+
+    user:
+      city-code: '0o10'
+
+   the following code snippets would **FAIL**:
+   ::
+
+    user:
+      city-code: 0o10
+"""
+
+import yaml
+
+from yamllint.linter import LintProblem
+
+
+ID = 'octal-values'
+TYPE = 'token'
+CONF = {'forbid-implicit-octal': bool,
+        'forbid-explicit-octal': bool}
+DEFAULT = {'forbid-implicit-octal': False,
+           'forbid-explicit-octal': False}
+
+
+def check(conf, token, prev, next, nextnext, context):
+    if prev and isinstance(prev, yaml.tokens.TagToken):
+        return
+
+    if conf['forbid-implicit-octal']:
+        if isinstance(token, yaml.tokens.ScalarToken):
+            if not token.style:
+                val = token.value
+                if val.isdigit() and len(val) > 1 and val[0] == '0':
+                    yield LintProblem(
+                        token.start_mark.line + 1, token.end_mark.column + 1,
+                        'forbidden implicit octal value "%s"' %
+                        token.value)
+
+    if conf['forbid-explicit-octal']:
+        if isinstance(token, yaml.tokens.ScalarToken):
+            if not token.style:
+                val = token.value
+                if len(val) > 2 and val[:2] == '0o' and val[2:].isdigit():
+                    yield LintProblem(
+                        token.start_mark.line + 1, token.end_mark.column + 1,
+                        'forbidden explicit octal value "%s"' %
+                        token.value)

yamllint/rules/quoted_strings.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018 ClearScore
+#
+# 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/>.
+
+"""
+Use this rule to forbid any string values that are not quoted.
+You can also enforce the type of the quote used using the ``quote-type`` option
+(``single``, ``double`` or ``any``).
+
+**Note**: Multi-line strings (with ``|`` or ``>``) will not be checked.
+
+.. rubric:: Examples
+
+#. With ``quoted-strings: {quote-type: any}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    foo: "bar"
+    bar: 'foo'
+    number: 123
+    boolean: true
+
+   the following code snippet would **FAIL**:
+   ::
+
+    foo: bar
+"""
+
+import yaml
+
+from yamllint.linter import LintProblem
+
+ID = 'quoted-strings'
+TYPE = 'token'
+CONF = {'quote-type': ('any', 'single', 'double')}
+DEFAULT = {'quote-type': 'any'}
+
+
+def check(conf, token, prev, next, nextnext, context):
+    quote_type = conf['quote-type']
+
+    if (isinstance(token, yaml.tokens.ScalarToken) and
+            isinstance(prev, (yaml.ValueToken, yaml.TagToken))):
+        # Ignore explicit types, e.g. !!str testtest or !!int 42
+        if (prev and isinstance(prev, yaml.tokens.TagToken) and
+                prev.value[0] == '!!'):
+            return
+
+        # Ignore numbers, booleans, etc.
+        resolver = yaml.resolver.Resolver()
+        if resolver.resolve(yaml.nodes.ScalarNode, token.value,
+                            (True, False)) != 'tag:yaml.org,2002:str':
+            return
+
+        # Ignore multi-line strings
+        if (not token.plain) and (token.style == "|" or token.style == ">"):
+            return
+
+        if ((quote_type == 'single' and token.style != "'") or
+                (quote_type == 'double' and token.style != '"') or
+                (quote_type == 'any' and token.style is None)):
+            yield LintProblem(
+                token.start_mark.line + 1,
+                token.start_mark.column + 1,
+                "string value is not quoted with %s quotes" % (quote_type))

yamllint/rules/truthy.py

@@ -15,11 +15,12 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Use this rule to forbid truthy values that are not quoted nor explicitly typed.
+Use this rule to forbid non-explictly typed truthy values other than ``true``
+and ``false``, for example ``YES``, ``False`` and ``off``.
 
-This would prevent YAML parsers from transforming ``[yes, FALSE, Off]`` into
-``[true, false, false]`` or ``{y: 1, yes: 2, on: 3, true: 4, True: 5}`` into
-``{y: 1, true: 5}``.
+This can be useful to prevent surprises from YAML parsers transforming
+``[yes, FALSE, Off]`` into ``[true, false, false]`` or
+``{y: 1, yes: 2, on: 3, true: 4, True: 5}`` into ``{y: 1, true: 5}``.
 
 .. rubric:: Examples
 
@@ -34,8 +35,7 @@ This would prevent YAML parsers from transforming ``[yes, FALSE, Off]`` into
 
     "yes":  1
     "on":   2
-    "true": 3
-    "True": 4
+    "True": 3
 
      explicit:
        string1: !!str True
@@ -62,8 +62,7 @@ This would prevent YAML parsers from transforming ``[yes, FALSE, Off]`` into
 
     yes:  1
     on:   2
-    true: 3
-    True: 4
+    True: 3
 """
 
 import yaml
@@ -72,7 +71,6 @@ from yamllint.linter import LintProblem
 
 ID = 'truthy'
 TYPE = 'token'
-CONF = {}
 
 TRUTHY = ['YES', 'Yes', 'yes',
           'NO', 'No', 'no',
@@ -90,4 +88,4 @@ def check(conf, token, prev, next, nextnext, context):
         if token.value in TRUTHY and token.style is None:
             yield LintProblem(token.start_mark.line + 1,
                               token.start_mark.column + 1,
-                              "truthy value is not quoted")
+                              "truthy value should be true or false")