yamllint version 1.21.0

Co-Authored-By: Adrien Vergé

.travis.yml

@@ -1,27 +1,22 @@
 ---
+dist: xenial  # required for Python >= 3.7 (travis-ci/travis-ci#9069)
 language: python
 python:
-  - 2.6
   - 2.7
-  - 3.3
-  - 3.4
   - 3.5
   - 3.6
+  - 3.7
+  - 3.8
   - nightly
 install:
-  - pip install pyyaml flake8 flake8-import-order
+  - pip install pyyaml coveralls flake8 flake8-import-order doc8
-  - if [[ $TRAVIS_PYTHON_VERSION == 2.6 ]]; then pip install unittest2; fi
-  - if [[ $TRAVIS_PYTHON_VERSION != 2.6 ]]; then pip install coveralls; fi
   - if [[ $TRAVIS_PYTHON_VERSION != 2* ]]; then pip install sphinx; fi
   - pip install .
 script:
-  - if [[ $TRAVIS_PYTHON_VERSION != 2.6 ]]; then flake8 .; fi
+  - 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')
-  - if [[ $TRAVIS_PYTHON_VERSION != 2.6 ]]; then
+  - coverage run --source=yamllint setup.py test
-      coverage run --source=yamllint setup.py test;
-    else
-      python setup.py test;
-    fi
   - if [[ $TRAVIS_PYTHON_VERSION != 2* ]]; then
       python setup.py build_sphinx;
     fi

CHANGELOG.rst

@@ -1,45 +1,101 @@
 Changelog
 =========
 
+1.21.0 (2020-03-24)
+-------------------
+
+- Fix ``new-lines`` rule on Python 3 with DOS line endings
+- Fix ``quoted-strings`` rule not working for string values matching scalars
+- Add ``required: only-when-needed`` option to the ``quoted-strings`` rule
+
+1.20.0 (2019-12-26)
+-------------------
+
+- Add --no-warnings option to suppress warning messages
+- Use 'syntax' as rule name upon syntax errors
+
+1.19.0 (2019-11-19)
+-------------------
+
+- Allow disabling all checks for a file with ``# yamllint disable-file``
+
+1.18.0 (2019-10-15)
+-------------------
+
+- Lint ``.yamllint`` config file by default
+- Also read config from ``.yamllint.yml`` and ``.yamllint.yaml``
+- Improve documentation for ``yaml-files``
+- Update documentation for ``pre-commit``
+- Explicitly disable ``empty-values`` and ``octal-values`` rules
+
+1.17.0 (2019-08-12)
+-------------------
+
+- Simplify installation instructions in the README
+- Add OpenBSD installation instructions
+- Make YAML file extensions configurable
+
+1.16.0 (2019-06-07)
+-------------------
+
+- Add FreeBSD installation instructions
+- Fix the ``line`` rule to correctly handle DOS new lines
+- Add the ``allowed-values`` option to the ``truthy`` rule
+- Allow configuration options to be a list of enums
+
+1.15.0 (2019-02-11)
+-------------------
+
+- Allow linting from standard input with ``yamllint -``
+
+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`
+- Use ``isinstance(x, y)`` instead of ``type(x) == y``
-- Add a new `-f colored` option
+- 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 the ``quoted-strings`` rule, broken implementation
-- Fix missing documentation for the `quoted-strings` rule
+- Fix missing documentation for the ``quoted-strings`` rule
 
 1.12.0 (2018-10-04)
 -------------------
 
-- Add a new `quoted-strings` rule
+- 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
+- Handle merge keys (``<<``) in the ``key-duplicates`` rule
 - Update documentation about pre-commit
-- Make examples for `ignore` rule clearer
+- 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
+- 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
+- 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
@@ -47,13 +103,13 @@ Changelog
 1.9.0 (2017-10-16)
 ------------------
 
-- Add a new `key-ordering` rule
+- 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
+- Be clearer about the ``ignore`` conf type
 - Update pre-commit hook file
 - Add documentation for pre-commit
 

README.rst

@@ -38,31 +38,16 @@ Screenshot
 Installation
 ^^^^^^^^^^^^
 
-On Fedora / CentOS (note: `EPEL <https://fedoraproject.org/wiki/EPEL>`_ is
+Using pip, the Python package manager:
-required on CentOS):
-
-.. code:: bash
-
- sudo dnf install yamllint
-
-On Debian 8+ / Ubuntu 16.04+:
-
-.. code:: bash
-
- sudo apt-get install yamllint
-
-On Mac OS 10.11+:
-
-.. code:: bash
-
- brew install yamllint
-
-Alternatively using pip, the Python package manager:
 
 .. code:: bash
 
  pip install --user yamllint
 
+yamllint is also packaged for all major operating systems, see installation
+examples (``dnf``, ``apt-get``...) `in the documentation
+<https://yamllint.readthedocs.io/en/stable/quickstart.html>`_.
+
 Usage
 ^^^^^
 

docs/conf.py

@@ -48,7 +48,7 @@ man_pages = [
 class Mock(MagicMock):
     @classmethod
     def __getattr__(cls, name):
-            return MagicMock()
+        return MagicMock()
 
 
 MOCK_MODULES = ['pathspec', 'yaml']

docs/configuration.rst

@@ -14,7 +14,8 @@ To use a custom configuration file, use the ``-c`` option:
 If ``-c`` is not provided, yamllint will look for a configuration file in the
 following locations (by order of preference):
 
-- ``.yamllint`` in the current working directory
+- ``.yamllint``, ``.yamllint.yaml`` or ``.yamllint.yml`` in the current working
+  directory
 - ``$XDG_CONFIG_HOME/yamllint/config``
 - ``~/.config/yamllint/config``
 
@@ -45,9 +46,9 @@ It can be chosen using:
 Extending the default configuration
 -----------------------------------
 
-When writing a custom configuration file, you don't need to redefine every rule.
+When writing a custom configuration file, you don't need to redefine every
-Just extend the ``default`` configuration (or any already-existing configuration
+rule. Just extend the ``default`` configuration (or any already-existing
-file).
+configuration file).
 
 For instance, if you just want to disable the ``comments-indentation`` rule,
 your file could look like this:
@@ -105,8 +106,8 @@ Problems detected by yamllint can be raised either as errors or as warnings.
 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
+By default the script will exit with a return code ``1`` *only when* there is
-more error(s).
+one or more error(s).
 
 However if strict mode is enabled with the ``-s`` (or ``--strict``) option, the
 return code will be:
@@ -115,6 +116,25 @@ return code will be:
  * ``1`` if one or more errors occur
  * ``2`` if no errors occur, but one or more warnings occur
 
+If the script is invoked with the ``--no-warnings`` option, it won't output
+warning level problems, only error level ones.
+
+YAML files extensions
+---------------------
+
+To configure what yamllint should consider as YAML files, set ``yaml-files``
+configuration option. The default is:
+
+.. code-block:: yaml
+
+ yaml-files:
+   - '*.yaml'
+   - '*.yml'
+   - '.yamllint'
+
+The same rules as for ignoring paths apply (``.gitignore``-style path pattern,
+see below).
+
 Ignoring paths
 --------------
 

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
+To prevent yamllint from reporting problems for a specific line, add a
-comment (``# yamllint disable-line ...``) on that line, or on the line above.
+directive comment (``# yamllint disable-line ...``) on that line, or on the
-For instance:
+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
+To prevent yamllint from reporting problems for the whole file, or for a block
-lines within the file, use ``# yamllint disable ...`` and ``# yamllint enable
+of lines within the file, use ``# yamllint disable ...`` and ``# yamllint
-...`` directive comments. For instance:
+enable ...`` directive comments. For instance:
 
 .. code-block:: yaml
 
@@ -73,3 +73,31 @@ It is possible, although not recommend, to disabled **all** rules:
 
 If you need to disable multiple rules, it is allowed to chain rules like this:
 ``# yamllint disable rule:hyphens rule:commas rule:indentation``.
+
+Disabling all checks for a file
+-------------------------------
+
+To prevent yamllint from reporting problems for a specific file, add the
+directive comment ``# yamllint disable-file`` as the first line of the file.
+For instance:
+
+.. code-block:: yaml
+
+ # yamllint disable-file
+ # The following mapping contains the same key twice, but I know what I'm doing:
+ key: value 1
+ key: value 2
+
+ - This line is waaaaaaaaaay too long but yamllint will not report anything about it.
+   This line will be checked by yamllint.
+
+or:
+
+.. code-block:: jinja
+
+ # yamllint disable-file
+ # This file is not valid YAML because it is a Jinja template
+ {% if extra_info %}
+ key1: value1
+ {% endif %}
+ key2: value2

docs/integration.rst

@@ -10,8 +10,10 @@ 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
+  # Update the rev variable with the release version that you want, from the yamllint repo
+  # You can pass your custom .yamllint with args attribute.
   - repo: https://github.com/adrienverge/yamllint.git
-    sha: v1.8.1
+    rev: v1.17.0
     hooks:
       - id: yamllint
+        args: [-c=/path/to/.yamllint]

docs/quickstart.rst

@@ -4,7 +4,8 @@ Quickstart
 Installing yamllint
 -------------------
 
-On Fedora / CentOS:
+On Fedora / CentOS (note: `EPEL <https://fedoraproject.org/wiki/EPEL>`_ is
+required on CentOS):
 
 .. code:: bash
 
@@ -22,6 +23,18 @@ On Mac OS 10.11+:
 
  brew install yamllint
 
+On FreeBSD:
+
+.. code:: sh
+
+  pkg install py36-yamllint
+
+On OpenBSD:
+
+.. code:: sh
+
+  doas pkg_add py3-yamllint
+
 Alternatively using pip, the Python package manager:
 
 .. code:: bash
@@ -50,6 +63,12 @@ You can also lint all YAML files in a whole directory:
 
  yamllint .
 
+Or lint a YAML stream from standard input:
+
+.. code:: bash
+
+ echo -e 'this: is\nvalid: YAML' | yamllint -
+
 The output will look like (colors are not displayed here):
 
 ::
@@ -68,9 +87,9 @@ 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
+By default, the output of yamllint is colored when run from a terminal, and
-text in other cases. Add the ``-f standard`` arguments to force non-colored output.
+pure text in other cases. Add the ``-f standard`` arguments to force
-Use the ``-f colored`` arguments to force colored output.
+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

setup.py

@@ -14,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from setuptools import setup, find_packages
+from setuptools import find_packages, setup
 
 from yamllint import (__author__, __license__,
                       APP_NAME, APP_VERSION, APP_DESCRIPTION)
@@ -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',

tests/common.py

@@ -16,12 +16,7 @@
 
 import os
 import tempfile
-import sys
+import unittest
-try:
-    assert sys.version_info >= (2, 7)
-    import unittest
-except AssertionError:
-    import unittest2 as unittest
 
 import yaml
 

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_lines.py

@@ -78,3 +78,22 @@ class EmptyLinesTestCase(RuleTestCase):
                 'document-start: disable\n')
         self.check('non empty\n', conf)
         self.check('non empty\n\n', conf, problem=(2, 1))
+
+    def test_with_dos_newlines(self):
+        conf = ('empty-lines: {max: 2, max-start: 0, max-end: 0}\n'
+                'new-lines: {type: dos}\n'
+                'document-start: disable\n')
+        self.check('---\r\n', conf)
+        self.check('---\r\ntext\r\n\r\ntext\r\n', conf)
+        self.check('\r\n---\r\ntext\r\n\r\ntext\r\n', conf,
+                   problem=(1, 1))
+        self.check('\r\n\r\n\r\n---\r\ntext\r\n\r\ntext\r\n', conf,
+                   problem=(3, 1))
+        self.check('---\r\ntext\r\n\r\n\r\n\r\ntext\r\n', conf,
+                   problem=(5, 1))
+        self.check('---\r\ntext\r\n\r\n\r\n\r\n\r\n\r\n\r\ntext\r\n', conf,
+                   problem=(8, 1))
+        self.check('---\r\ntext\r\n\r\ntext\r\n\r\n', conf,
+                   problem=(5, 1))
+        self.check('---\r\ntext\r\n\r\ntext\r\n\r\n\r\n\r\n', conf,
+                   problem=(7, 1))

tests/rules/test_indentation.py

@@ -51,8 +51,8 @@ class IndentationStackTestCase(RuleTestCase):
                           .replace('Mapping', 'Map'))
             if token_type in ('StreamStart', 'StreamEnd'):
                 continue
-            output += '%9s %s\n' % (token_type,
+            output += '{:>9} {}\n'.format(token_type,
-                                    self.format_stack(context['stack']))
+                                          self.format_stack(context['stack']))
         return output
 
     def test_simple_mapping(self):

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,25 @@ 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))
+
+    def test_with_dos_newlines(self):
+        conf = ('line-length: {max: 10}\n'
+                'new-lines: {type: dos}\n'
+                'new-line-at-end-of-file: disable\n')
+        self.check('---\r\nABCD EFGHI', conf)
+        self.check('---\r\nABCD EFGHI\r\n', conf)
+        self.check('---\r\nABCD EFGHIJ', conf, problem=(2, 11))
+        self.check('---\r\nABCD EFGHIJ\r\n', conf, problem=(2, 11))

tests/rules/test_new_lines.py

@@ -31,16 +31,20 @@ class NewLinesTestCase(RuleTestCase):
         self.check('---\r\ntext\r\n', conf)
 
     def test_unix_type(self):
-        conf = 'new-lines: {type: unix}'
+        conf = ('new-line-at-end-of-file: disable\n'
+                'new-lines: {type: unix}\n')
         self.check('', conf)
+        self.check('\r', conf)
         self.check('\n', conf)
         self.check('\r\n', conf, problem=(1, 1))
         self.check('---\ntext\n', conf)
         self.check('---\r\ntext\r\n', conf, problem=(1, 4))
 
     def test_dos_type(self):
-        conf = 'new-lines: {type: dos}\n'
+        conf = ('new-line-at-end-of-file: disable\n'
+                'new-lines: {type: dos}\n')
         self.check('', conf)
+        self.check('\r', conf)
         self.check('\n', conf, problem=(1, 1))
         self.check('\r\n', conf)
         self.check('---\ntext\n', conf, problem=(1, 4))

tests/rules/test_octal_values.py

@@ -28,7 +28,9 @@ class OctalValuesTestCase(RuleTestCase):
         self.check('user-city: 0o10', conf)
 
     def test_implicit_octal_values(self):
-        conf = ('octal-values: {forbid-implicit-octal: true}\n'
+        conf = ('octal-values:\n'
+                '  forbid-implicit-octal: true\n'
+                '  forbid-explicit-octal: false\n'
                 'new-line-at-end-of-file: disable\n'
                 'document-start: disable\n')
         self.check('user-city: 010', conf, problem=(1, 15))
@@ -50,7 +52,9 @@ class OctalValuesTestCase(RuleTestCase):
                    '  - 0e3\n', conf)
 
     def test_explicit_octal_values(self):
-        conf = ('octal-values: {forbid-explicit-octal: true}\n'
+        conf = ('octal-values:\n'
+                '  forbid-implicit-octal: false\n'
+                '  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))

tests/rules/test_quoted_strings.py

@@ -22,6 +22,7 @@ class QuotedTestCase(RuleTestCase):
 
     def test_disabled(self):
         conf = 'quoted-strings: disable'
+
         self.check('---\n'
                    'foo: bar\n', conf)
         self.check('---\n'
@@ -30,18 +31,23 @@ class QuotedTestCase(RuleTestCase):
                    'foo: \'bar\'\n', conf)
         self.check('---\n'
                    'bar: 123\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'
+                   'string3: "true"\n'
-                   'string4: !!str genericstring\n'
+                   'string4: "123"\n'
-                   'string5: !!str 456\n'
+                   'string5: \'bar\'\n'
-                   'string6: !!str "quotedgenericstring"\n'
+                   'string6: !!str genericstring\n'
+                   'string7: !!str 456\n'
+                   'string8: !!str "quotedgenericstring"\n'
                    'binary: !!binary binstring\n'
                    'integer: !!int intstring\n'
                    'boolean2: !!bool boolstring\n'
@@ -55,7 +61,7 @@ class QuotedTestCase(RuleTestCase):
                    '  word 1\n'
                    '  word 2\n'
                    'multiline string 3:\n'
-                   '  word 1\n'
+                   '  word 1\n'               # fails
                    '  word 2\n'
                    'multiline string 4:\n'
                    '  "word 1\\\n'
@@ -64,20 +70,24 @@ class QuotedTestCase(RuleTestCase):
 
     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'
+                   'string3: "true"\n'                       # fails
-                   'string4: !!str genericstring\n'
+                   'string4: "123"\n'                        # fails
-                   'string5: !!str 456\n'
+                   'string5: \'bar\'\n'
-                   'string6: !!str "quotedgenericstring"\n'
+                   'string6: !!str genericstring\n'
+                   'string7: !!str 456\n'
+                   'string8: !!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))
+                   conf, problem1=(4, 10), problem2=(5, 10),
+                   problem3=(6, 10), problem4=(7, 10))
         self.check('---\n'
                    'multiline string 1: |\n'
                    '  line 1\n'
@@ -86,7 +96,7 @@ class QuotedTestCase(RuleTestCase):
                    '  word 1\n'
                    '  word 2\n'
                    'multiline string 3:\n'
-                   '  word 1\n'
+                   '  word 1\n'               # fails
                    '  word 2\n'
                    'multiline string 4:\n'
                    '  "word 1\\\n'
@@ -95,20 +105,162 @@ class QuotedTestCase(RuleTestCase):
 
     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
+                   'string3: "true"\n'
-                   'string4: !!str genericstring\n'
+                   'string4: "123"\n'
-                   'string5: !!str 456\n'
+                   'string5: \'bar\'\n'                      # fails
-                   'string6: !!str "quotedgenericstring"\n'
+                   'string6: !!str genericstring\n'
+                   'string7: !!str 456\n'
+                   'string8: !!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))
+                   conf, problem1=(4, 10), problem2=(8, 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'               # fails
+                   '  word 2\n'
+                   'multiline string 4:\n'
+                   '  "word 1\\\n'
+                   '   word 2"\n',
+                   conf, problem1=(9, 3))
+
+    def test_disallow_redundant_quotes(self):
+        conf = 'quoted-strings: {required: only-when-needed}\n'
+
+        self.check('---\n'
+                   'boolean1: true\n'
+                   'number1: 123\n'
+                   'string1: foo\n'
+                   'string2: "foo"\n'                        # fails
+                   'string3: "true"\n'
+                   'string4: "123"\n'
+                   'string5: \'bar\'\n'                      # fails
+                   'string6: !!str genericstring\n'
+                   'string7: !!str 456\n'
+                   'string8: !!str "quotedgenericstring"\n'
+                   'binary: !!binary binstring\n'
+                   'integer: !!int intstring\n'
+                   'boolean2: !!bool boolstring\n'
+                   'boolean3: !!bool "quotedboolstring"\n',
+                   conf, problem1=(5, 10), problem2=(8, 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'            # fails
+                   '   word 2"\n',
+                   conf, problem1=(12, 3))
+
+    def test_disallow_redundant_single_quotes(self):
+        conf = 'quoted-strings: {quote-type: single, ' + \
+                                'required: only-when-needed}\n'
+
+        self.check('---\n'
+                   'boolean1: true\n'
+                   'number1: 123\n'
+                   'string1: foo\n'
+                   'string2: "foo"\n'                        # fails
+                   'string3: "true"\n'                       # fails
+                   'string4: "123"\n'                        # fails
+                   'string5: \'bar\'\n'                      # fails
+                   'string6: !!str genericstring\n'
+                   'string7: !!str 456\n'
+                   'string8: !!str "quotedgenericstring"\n'
+                   'binary: !!binary binstring\n'
+                   'integer: !!int intstring\n'
+                   'boolean2: !!bool boolstring\n'
+                   'boolean3: !!bool "quotedboolstring"\n',
+                   conf, problem1=(5, 10), problem2=(6, 10),
+                   problem3=(7, 10), problem4=(8, 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'            # fails
+                   '   word 2"\n',
+                   conf, problem1=(12, 3))
+
+    def test_single_quotes_required(self):
+        conf = 'quoted-strings: {quote-type: single, required: true}\n'
+
+        self.check('---\n'
+                   'boolean1: true\n'
+                   'number1: 123\n'
+                   'string1: foo\n'                          # fails
+                   'string2: "foo"\n'                        # fails
+                   'string3: "true"\n'                       # fails
+                   'string4: "123"\n'                        # fails
+                   'string5: \'bar\'\n'
+                   'string6: !!str genericstring\n'
+                   'string7: !!str 456\n'
+                   'string8: !!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),
+                   problem3=(6, 10), problem4=(7, 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'               # fails
+                   '  word 2\n'
+                   'multiline string 4:\n'
+                   '  "word 1\\\n'            # fails
+                   '   word 2"\n',
+                   conf, problem1=(9, 3), problem2=(12, 3))
+
+    def test_any_quotes_relaxed(self):
+        conf = 'quoted-strings: {quote-type: any, required: false}\n'
+
+        self.check('---\n'
+                   'boolean1: true\n'
+                   'number1: 123\n'
+                   'string1: foo\n'
+                   'string2: "foo"\n'
+                   'string3: "true"\n'
+                   'string4: "123"\n'
+                   'string5: \'bar\'\n'
+                   'string6: !!str genericstring\n'
+                   'string7: !!str 456\n'
+                   'string8: !!str "quotedgenericstring"\n'
+                   'binary: !!binary binstring\n'
+                   'integer: !!int intstring\n'
+                   'boolean2: !!bool boolstring\n'
+                   'boolean3: !!bool "quotedboolstring"\n',
+                   conf)
         self.check('---\n'
                    'multiline string 1: |\n'
                    '  line 1\n'
@@ -122,4 +274,73 @@ class QuotedTestCase(RuleTestCase):
                    'multiline string 4:\n'
                    '  "word 1\\\n'
                    '   word 2"\n',
+                   conf)
+
+    def test_single_quotes_relaxed(self):
+        conf = 'quoted-strings: {quote-type: single, required: false}\n'
+
+        self.check('---\n'
+                   'boolean1: true\n'
+                   'number1: 123\n'
+                   'string1: foo\n'
+                   'string2: "foo"\n'                        # fails
+                   'string3: "true"\n'                       # fails
+                   'string4: "123"\n'                        # fails
+                   'string5: \'bar\'\n'
+                   'string6: !!str genericstring\n'
+                   'string7: !!str 456\n'
+                   'string8: !!str "quotedgenericstring"\n'
+                   'binary: !!binary binstring\n'
+                   'integer: !!int intstring\n'
+                   'boolean2: !!bool boolstring\n'
+                   'boolean3: !!bool "quotedboolstring"\n',
+                   conf, problem2=(5, 10),
+                   problem3=(6, 10), problem4=(7, 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'            # fails
+                   '   word 2"\n',
+                   conf, problem1=(12, 3))
+
+    def test_quotes_required(self):
+        conf = 'quoted-strings: {quote-type: any, required: true}\n'
+
+        self.check('---\n'
+                   'boolean1: true\n'
+                   'number1: 123\n'
+                   'string1: foo\n'                          # fails
+                   'string2: "foo"\n'
+                   'string3: "true"\n'
+                   'string4: "123"\n'
+                   'string5: \'bar\'\n'
+                   'string6: !!str genericstring\n'
+                   'string7: !!str 456\n'
+                   'string8: !!str "quotedgenericstring"\n'
+                   'binary: !!binary binstring\n'
+                   'integer: !!int intstring\n'
+                   'boolean2: !!bool boolstring\n'
+                   'boolean3: !!bool "quotedboolstring"\n',
+                   conf, problem2=(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'               # fails
+                   '  word 2\n'
+                   'multiline string 4:\n'
+                   '  "word 1\\\n'
+                   '   word 2"\n',
                    conf, problem1=(9, 3))

tests/rules/test_truthy.py

@@ -49,6 +49,54 @@ class TruthyTestCase(RuleTestCase):
                    problem3=(7, 3), problem4=(7, 7),
                    problem5=(8, 3), problem6=(8, 7))
 
+    def test_different_allowed_values(self):
+        conf = ('truthy:\n'
+                '  allowed-values: ["yes", "no"]\n')
+        self.check('---\n'
+                   'key1: foo\n'
+                   'key2: yes\n'
+                   'key3: bar\n'
+                   'key4: no\n', conf)
+        self.check('---\n'
+                   'key1: true\n'
+                   'key2: Yes\n'
+                   'key3: false\n'
+                   'key4: no\n'
+                   'key5: yes\n',
+                   conf,
+                   problem1=(2, 7), problem2=(3, 7),
+                   problem3=(4, 7))
+
+    def test_combined_allowed_values(self):
+        conf = ('truthy:\n'
+                '  allowed-values: ["yes", "no", "true", "false"]\n')
+        self.check('---\n'
+                   'key1: foo\n'
+                   'key2: yes\n'
+                   'key3: bar\n'
+                   'key4: no\n', conf)
+        self.check('---\n'
+                   'key1: true\n'
+                   'key2: Yes\n'
+                   'key3: false\n'
+                   'key4: no\n'
+                   'key5: yes\n',
+                   conf, problem1=(3, 7))
+
+    def test_no_allowed_values(self):
+        conf = ('truthy:\n'
+                '  allowed-values: []\n')
+        self.check('---\n'
+                   'key1: foo\n'
+                   'key2: bar\n', conf)
+        self.check('---\n'
+                   'key1: true\n'
+                   'key2: yes\n'
+                   'key3: false\n'
+                   'key4: no\n', conf,
+                   problem1=(2, 7), problem2=(3, 7),
+                   problem3=(4, 7), problem4=(5, 7))
+
     def test_explicit_types(self):
         conf = 'truthy: enable\n'
         self.check('---\n'

tests/test_cli.py

@@ -24,18 +24,37 @@ import os
 import pty
 import shutil
 import sys
-try:
+import unittest
-    assert sys.version_info >= (2, 7)
-    import unittest
-except AssertionError:
-    import unittest2 as unittest
 
 from tests.common import build_temp_workspace
 
 from yamllint import cli
+from yamllint import config
+
+
+class RunContext(object):
+    """Context manager for ``cli.run()`` to capture exit code and streams."""
+
+    def __init__(self, case):
+        self.stdout = self.stderr = None
+        self._raises_ctx = case.assertRaises(SystemExit)
+
+    def __enter__(self):
+        self._raises_ctx.__enter__()
+        sys.stdout = self.outstream = StringIO()
+        sys.stderr = self.errstream = StringIO()
+        return self
+
+    def __exit__(self, *exc_info):
+        self.stdout, sys.stdout = self.outstream.getvalue(), sys.__stdout__
+        self.stderr, sys.stderr = self.errstream.getvalue(), sys.__stderr__
+        return self._raises_ctx.__exit__(*exc_info)
+
+    @property
+    def returncode(self):
+        return self._raises_ctx.exception.code
 
 
-@unittest.skipIf(sys.version_info < (2, 7), 'Python 2.6 not supported')
 class CommandLineTestCase(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -63,12 +82,15 @@ class CommandLineTestCase(unittest.TestCase):
             'no-yaml.json': '---\n'
                             'key: value\n',
             # non-ASCII chars
-            'non-ascii/utf-8': (
+            'non-ascii/éçäγλνπ¥/utf-8': (
                 u'---\n'
                 u'- hétérogénéité\n'
                 u'# 19.99 €\n'
                 u'- お早う御座います。\n'
                 u'# الأَبْجَدِيَّة العَرَبِيَّة\n').encode('utf-8'),
+            # dos line endings yaml
+            'dos.yml': '---\r\n'
+                       'dos: true',
         })
 
     @classmethod
@@ -78,9 +100,11 @@ class CommandLineTestCase(unittest.TestCase):
         shutil.rmtree(cls.wd)
 
     def test_find_files_recursively(self):
+        conf = config.YamlLintConfig('extends: default')
         self.assertEqual(
-            sorted(cli.find_files_recursively([self.wd])),
+            sorted(cli.find_files_recursively([self.wd], conf)),
             [os.path.join(self.wd, 'a.yaml'),
+             os.path.join(self.wd, 'dos.yml'),
              os.path.join(self.wd, 'empty.yml'),
              os.path.join(self.wd, 's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'),
              os.path.join(self.wd, 'sub/ok.yaml'),
@@ -90,14 +114,14 @@ class CommandLineTestCase(unittest.TestCase):
         items = [os.path.join(self.wd, 'sub/ok.yaml'),
                  os.path.join(self.wd, 'empty-dir')]
         self.assertEqual(
-            sorted(cli.find_files_recursively(items)),
+            sorted(cli.find_files_recursively(items, conf)),
             [os.path.join(self.wd, 'sub/ok.yaml')],
         )
 
         items = [os.path.join(self.wd, 'empty.yml'),
                  os.path.join(self.wd, 's')]
         self.assertEqual(
-            sorted(cli.find_files_recursively(items)),
+            sorted(cli.find_files_recursively(items, conf)),
             [os.path.join(self.wd, 'empty.yml'),
              os.path.join(self.wd, 's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml')],
         )
@@ -105,196 +129,219 @@ class CommandLineTestCase(unittest.TestCase):
         items = [os.path.join(self.wd, 'sub'),
                  os.path.join(self.wd, '/etc/another/file')]
         self.assertEqual(
-            sorted(cli.find_files_recursively(items)),
+            sorted(cli.find_files_recursively(items, conf)),
             [os.path.join(self.wd, '/etc/another/file'),
              os.path.join(self.wd, 'sub/ok.yaml')],
         )
 
+        conf = config.YamlLintConfig('extends: default\n'
+                                     'yaml-files:\n'
+                                     '  - \'*.yaml\' \n')
+        self.assertEqual(
+            sorted(cli.find_files_recursively([self.wd], conf)),
+            [os.path.join(self.wd, 'a.yaml'),
+             os.path.join(self.wd, 's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'),
+             os.path.join(self.wd, 'sub/ok.yaml'),
+             os.path.join(self.wd, 'warn.yaml')]
+        )
+
+        conf = config.YamlLintConfig('extends: default\n'
+                                     'yaml-files:\n'
+                                     '  - \'*.yml\'\n')
+        self.assertEqual(
+            sorted(cli.find_files_recursively([self.wd], conf)),
+            [os.path.join(self.wd, 'dos.yml'),
+             os.path.join(self.wd, 'empty.yml')]
+        )
+
+        conf = config.YamlLintConfig('extends: default\n'
+                                     'yaml-files:\n'
+                                     '  - \'*.json\'\n')
+        self.assertEqual(
+            sorted(cli.find_files_recursively([self.wd], conf)),
+            [os.path.join(self.wd, 'no-yaml.json')]
+        )
+
+        conf = config.YamlLintConfig('extends: default\n'
+                                     'yaml-files:\n'
+                                     '  - \'*\'\n')
+        self.assertEqual(
+            sorted(cli.find_files_recursively([self.wd], conf)),
+            [os.path.join(self.wd, 'a.yaml'),
+             os.path.join(self.wd, 'dos.yml'),
+             os.path.join(self.wd, 'empty.yml'),
+             os.path.join(self.wd, 'no-yaml.json'),
+             os.path.join(self.wd, 'non-ascii/éçäγλνπ¥/utf-8'),
+             os.path.join(self.wd, 's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'),
+             os.path.join(self.wd, 'sub/ok.yaml'),
+             os.path.join(self.wd, 'warn.yaml')]
+        )
+
+        conf = config.YamlLintConfig('extends: default\n'
+                                     'yaml-files:\n'
+                                     '  - \'*.yaml\'\n'
+                                     '  - \'*\'\n'
+                                     '  - \'**\'\n')
+        self.assertEqual(
+            sorted(cli.find_files_recursively([self.wd], conf)),
+            [os.path.join(self.wd, 'a.yaml'),
+             os.path.join(self.wd, 'dos.yml'),
+             os.path.join(self.wd, 'empty.yml'),
+             os.path.join(self.wd, 'no-yaml.json'),
+             os.path.join(self.wd, 'non-ascii/éçäγλνπ¥/utf-8'),
+             os.path.join(self.wd, 's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'),
+             os.path.join(self.wd, 'sub/ok.yaml'),
+             os.path.join(self.wd, 'warn.yaml')]
+        )
+
+        conf = config.YamlLintConfig('extends: default\n'
+                                     'yaml-files:\n'
+                                     '  - \'s/**\'\n'
+                                     '  - \'**/utf-8\'\n')
+        self.assertEqual(
+            sorted(cli.find_files_recursively([self.wd], conf)),
+            [os.path.join(self.wd, 'non-ascii/éçäγλνπ¥/utf-8')]
+        )
+
     def test_run_with_bad_arguments(self):
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
             cli.run(())
+        self.assertNotEqual(ctx.returncode, 0)
+        self.assertEqual(ctx.stdout, '')
+        self.assertRegexpMatches(ctx.stderr, r'^usage')
 
-        self.assertNotEqual(ctx.exception.code, 0)
+        with RunContext(self) as ctx:
-
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, '')
-        self.assertRegexpMatches(err, r'^usage')
-
-        sys.stdout, sys.stderr = StringIO(), StringIO()
-        with self.assertRaises(SystemExit) as ctx:
             cli.run(('--unknown-arg', ))
+        self.assertNotEqual(ctx.returncode, 0)
+        self.assertEqual(ctx.stdout, '')
+        self.assertRegexpMatches(ctx.stderr, r'^usage')
 
-        self.assertNotEqual(ctx.exception.code, 0)
+        with RunContext(self) as ctx:
-
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, '')
-        self.assertRegexpMatches(err, r'^usage')
-
-        sys.stdout, sys.stderr = StringIO(), StringIO()
-        with self.assertRaises(SystemExit) as ctx:
             cli.run(('-c', './conf.yaml', '-d', 'relaxed', 'file'))
-
+        self.assertNotEqual(ctx.returncode, 0)
-        self.assertNotEqual(ctx.exception.code, 0)
+        self.assertEqual(ctx.stdout, '')
-
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, '')
         self.assertRegexpMatches(
-            err.splitlines()[-1],
+            ctx.stderr.splitlines()[-1],
             r'^yamllint: error: argument -d\/--config-data: '
             r'not allowed with argument -c\/--config-file$'
         )
 
+        # checks if reading from stdin and files are mutually exclusive
+        with RunContext(self) as ctx:
+            cli.run(('-', 'file'))
+        self.assertNotEqual(ctx.returncode, 0)
+        self.assertEqual(ctx.stdout, '')
+        self.assertRegexpMatches(ctx.stderr, r'^usage')
+
     def test_run_with_bad_config(self):
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
             cli.run(('-d', 'rules: {a: b}', 'file'))
-
+        self.assertEqual(ctx.returncode, -1)
-        self.assertEqual(ctx.exception.code, -1)
+        self.assertEqual(ctx.stdout, '')
-
+        self.assertRegexpMatches(ctx.stderr, r'^invalid config: no such rule')
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, '')
-        self.assertRegexpMatches(err, r'^invalid config: no such rule')
 
     def test_run_with_empty_config(self):
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
             cli.run(('-d', '', 'file'))
-
+        self.assertEqual(ctx.returncode, -1)
-        self.assertEqual(ctx.exception.code, -1)
+        self.assertEqual(ctx.stdout, '')
-
+        self.assertRegexpMatches(ctx.stderr, r'^invalid config: not a dict')
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, '')
-        self.assertRegexpMatches(err, r'^invalid config: not a dict')
 
     def test_run_with_config_file(self):
         with open(os.path.join(self.wd, 'config'), 'w') as f:
             f.write('rules: {trailing-spaces: disable}')
 
-        with self.assertRaises(SystemExit) as ctx:
+        with RunContext(self) as ctx:
             cli.run(('-c', f.name, os.path.join(self.wd, 'a.yaml')))
-        self.assertEqual(ctx.exception.code, 0)
+        self.assertEqual(ctx.returncode, 0)
 
         with open(os.path.join(self.wd, 'config'), 'w') as f:
             f.write('rules: {trailing-spaces: enable}')
 
-        with self.assertRaises(SystemExit) as ctx:
+        with RunContext(self) as ctx:
             cli.run(('-c', f.name, os.path.join(self.wd, 'a.yaml')))
-        self.assertEqual(ctx.exception.code, 1)
+        self.assertEqual(ctx.returncode, 1)
 
     def test_run_with_user_global_config_file(self):
         home = os.path.join(self.wd, 'fake-home')
-        os.mkdir(home)
+        dir = os.path.join(home, '.config', 'yamllint')
-        dir = os.path.join(home, '.config')
+        os.makedirs(dir)
-        os.mkdir(dir)
-        dir = os.path.join(dir, 'yamllint')
-        os.mkdir(dir)
         config = os.path.join(dir, 'config')
 
-        temp = os.environ['HOME']
+        self.addCleanup(os.environ.update, HOME=os.environ['HOME'])
         os.environ['HOME'] = home
 
         with open(config, 'w') as f:
             f.write('rules: {trailing-spaces: disable}')
 
-        with self.assertRaises(SystemExit) as ctx:
+        with RunContext(self) as ctx:
             cli.run((os.path.join(self.wd, 'a.yaml'), ))
-        self.assertEqual(ctx.exception.code, 0)
+        self.assertEqual(ctx.returncode, 0)
 
         with open(config, 'w') as f:
             f.write('rules: {trailing-spaces: enable}')
 
-        with self.assertRaises(SystemExit) as ctx:
+        with RunContext(self) as ctx:
             cli.run((os.path.join(self.wd, 'a.yaml'), ))
-        self.assertEqual(ctx.exception.code, 1)
+        self.assertEqual(ctx.returncode, 1)
-
-        os.environ['HOME'] = temp
 
     def test_run_version(self):
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
             cli.run(('--version', ))
-
+        self.assertEqual(ctx.returncode, 0)
-        self.assertEqual(ctx.exception.code, 0)
+        self.assertRegexpMatches(ctx.stdout + ctx.stderr, r'yamllint \d+\.\d+')
-
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertRegexpMatches(out + err, r'yamllint \d+\.\d+')
 
     def test_run_non_existing_file(self):
-        file = os.path.join(self.wd, 'i-do-not-exist.yaml')
+        path = os.path.join(self.wd, 'i-do-not-exist.yaml')
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', path))
-            cli.run(('-f', 'parsable', file))
+        self.assertEqual(ctx.returncode, -1)
-
+        self.assertEqual(ctx.stdout, '')
-        self.assertEqual(ctx.exception.code, -1)
+        self.assertRegexpMatches(ctx.stderr, r'No such file or directory')
-
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, '')
-        self.assertRegexpMatches(err, r'No such file or directory')
 
     def test_run_one_problem_file(self):
-        file = os.path.join(self.wd, 'a.yaml')
+        path = os.path.join(self.wd, 'a.yaml')
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', path))
-            cli.run(('-f', 'parsable', file))
+        self.assertEqual(ctx.returncode, 1)
-
+        self.assertEqual(ctx.stdout, (
-        self.assertEqual(ctx.exception.code, 1)
-
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, (
             '%s:2:4: [error] trailing spaces (trailing-spaces)\n'
             '%s:3:4: [error] no new line character at the end of file '
-            '(new-line-at-end-of-file)\n') % (file, file))
+            '(new-line-at-end-of-file)\n' % (path, path)))
-        self.assertEqual(err, '')
+        self.assertEqual(ctx.stderr, '')
 
     def test_run_one_warning(self):
-        file = os.path.join(self.wd, 'warn.yaml')
+        path = os.path.join(self.wd, 'warn.yaml')
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', path))
-            cli.run(('-f', 'parsable', file))
+        self.assertEqual(ctx.returncode, 0)
-
-        self.assertEqual(ctx.exception.code, 0)
 
     def test_run_warning_in_strict_mode(self):
-        file = os.path.join(self.wd, 'warn.yaml')
+        path = os.path.join(self.wd, 'warn.yaml')
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', '--strict', path))
-            cli.run(('-f', 'parsable', '--strict', file))
+        self.assertEqual(ctx.returncode, 2)
-
-        self.assertEqual(ctx.exception.code, 2)
 
     def test_run_one_ok_file(self):
-        file = os.path.join(self.wd, 'sub', 'ok.yaml')
+        path = os.path.join(self.wd, 'sub', 'ok.yaml')
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', path))
-            cli.run(('-f', 'parsable', file))
+        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
-
-        self.assertEqual(ctx.exception.code, 0)
-
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, '')
-        self.assertEqual(err, '')
 
     def test_run_empty_file(self):
-        file = os.path.join(self.wd, 'empty.yml')
+        path = os.path.join(self.wd, 'empty.yml')
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', path))
-            cli.run(('-f', 'parsable', file))
+        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
-
-        self.assertEqual(ctx.exception.code, 0)
-
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, '')
-        self.assertEqual(err, '')
 
     def test_run_non_ascii_file(self):
-        file = os.path.join(self.wd, 'non-ascii', 'utf-8')
+        path = os.path.join(self.wd, 'non-ascii', 'éçäγλνπ¥', 'utf-8')
 
         # Make sure the default localization conditions on this "system"
         # support UTF-8 encoding.
@@ -303,63 +350,46 @@ class CommandLineTestCase(unittest.TestCase):
             locale.setlocale(locale.LC_ALL, 'C.UTF-8')
         except locale.Error:
             locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
+        self.addCleanup(locale.setlocale, locale.LC_ALL, loc)
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', path))
-            cli.run(('-f', 'parsable', file))
+        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
-
-        locale.setlocale(locale.LC_ALL, loc)
-
-        self.assertEqual(ctx.exception.code, 0)
-
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, '')
-        self.assertEqual(err, '')
 
     def test_run_multiple_files(self):
         items = [os.path.join(self.wd, 'empty.yml'),
                  os.path.join(self.wd, 's')]
-        file = items[1] + '/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'
+        path = items[1] + '/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
             cli.run(['-f', 'parsable'] + items)
-
+        self.assertEqual((ctx.returncode, ctx.stderr), (1, ''))
-        self.assertEqual(ctx.exception.code, 1)
+        self.assertEqual(ctx.stdout, (
-
-        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertEqual(out, (
             '%s:3:1: [error] duplication of key "key" in mapping '
-            '(key-duplicates)\n') % file)
+            '(key-duplicates)\n') % path)
-        self.assertEqual(err, '')
 
     def test_run_piped_output_nocolor(self):
-        file = os.path.join(self.wd, 'a.yaml')
+        path = os.path.join(self.wd, 'a.yaml')
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run((path, ))
-            cli.run((file, ))
+        self.assertEqual((ctx.returncode, ctx.stderr), (1, ''))
-
+        self.assertEqual(ctx.stdout, (
-        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))
+            '\n' % path))
-        self.assertEqual(err, '')
 
     def test_run_default_format_output_in_tty(self):
-        file = os.path.join(self.wd, 'a.yaml')
+        path = os.path.join(self.wd, 'a.yaml')
 
         # Create a pseudo-TTY and redirect stdout to it
         master, slave = pty.openpty()
         sys.stdout = sys.stderr = os.fdopen(slave, 'w')
 
         with self.assertRaises(SystemExit) as ctx:
-            cli.run((file, ))
+            cli.run((path, ))
         sys.stdout.flush()
 
         self.assertEqual(ctx.exception.code, 1)
@@ -382,60 +412,108 @@ class CommandLineTestCase(unittest.TestCase):
             '  \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))
+            '\n' % path))
 
     def test_run_default_format_output_without_tty(self):
-        file = os.path.join(self.wd, 'a.yaml')
+        path = os.path.join(self.wd, 'a.yaml')
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run((path, ))
-            cli.run((file, ))
+        expected_out = (
-
-        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))
+            '\n' % path)
-        self.assertEqual(err, '')
+        self.assertEqual(
+            (ctx.returncode, ctx.stdout, ctx.stderr), (1, expected_out, ''))
 
     def test_run_auto_output_without_tty_output(self):
-        file = os.path.join(self.wd, 'a.yaml')
+        path = os.path.join(self.wd, 'a.yaml')
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run((path, '--format', 'auto'))
-            cli.run((file, '--format', 'auto'))
+        expected_out = (
-
-        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))
+            '\n' % path)
-        self.assertEqual(err, '')
+        self.assertEqual(
+            (ctx.returncode, ctx.stdout, ctx.stderr), (1, expected_out, ''))
 
     def test_run_format_colored(self):
-        file = os.path.join(self.wd, 'a.yaml')
+        path = os.path.join(self.wd, 'a.yaml')
 
-        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with RunContext(self) as ctx:
-        with self.assertRaises(SystemExit) as ctx:
+            cli.run((path, '--format', 'colored'))
-            cli.run((file, '--format', 'colored'))
+        expected_out = (
-
-        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))
+            '\n' % path)
-        self.assertEqual(err, '')
+        self.assertEqual(
+            (ctx.returncode, ctx.stdout, ctx.stderr), (1, expected_out, ''))
+
+    def test_run_read_from_stdin(self):
+        # prepares stdin with an invalid yaml string so that we can check
+        # for its specific error, and be assured that stdin was read
+        self.addCleanup(setattr, sys, 'stdin', sys.__stdin__)
+        sys.stdin = StringIO(
+            'I am a string\n'
+            'therefore: I am an error\n')
+
+        with RunContext(self) as ctx:
+            cli.run(('-', '-f', 'parsable'))
+        expected_out = (
+            'stdin:2:10: [error] syntax error: '
+            'mapping values are not allowed here (syntax)\n')
+        self.assertEqual(
+            (ctx.returncode, ctx.stdout, ctx.stderr), (1, expected_out, ''))
+
+    def test_run_no_warnings(self):
+        path = os.path.join(self.wd, 'a.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run((path, '--no-warnings', '-f', 'auto'))
+        expected_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' % path)
+        self.assertEqual(
+            (ctx.returncode, ctx.stdout, ctx.stderr), (1, expected_out, ''))
+
+        path = os.path.join(self.wd, 'warn.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run((path, '--no-warnings', '-f', 'auto'))
+        self.assertEqual(ctx.returncode, 0)
+
+    def test_run_no_warnings_and_strict(self):
+        path = os.path.join(self.wd, 'warn.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run((path, '--no-warnings', '-s'))
+        self.assertEqual(ctx.returncode, 2)
+
+    def test_run_non_universal_newline(self):
+        path = os.path.join(self.wd, 'dos.yml')
+
+        with RunContext(self) as ctx:
+            cli.run(('-d', 'rules:\n  new-lines:\n    type: dos', path))
+        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
+
+        with RunContext(self) as ctx:
+            cli.run(('-d', 'rules:\n  new-lines:\n    type: unix', path))
+        expected_out = (
+            '%s\n'
+            '  1:4       error    wrong new line character: expected \\n'
+            '  (new-lines)\n'
+            '\n' % path)
+        self.assertEqual(
+            (ctx.returncode, ctx.stdout, ctx.stderr), (1, expected_out, ''))

tests/test_config.py

@@ -21,11 +21,8 @@ except ImportError:
 import os
 import shutil
 import sys
-try:
+import tempfile
-    assert sys.version_info >= (2, 7)
+import unittest
-    import unittest
-except AssertionError:
-    import unittest2 as unittest
 
 from tests.common import build_temp_workspace
 
@@ -58,13 +55,16 @@ class SimpleConfigTestCase(unittest.TestCase):
                                   '  this-one-does-not-exist: enable\n')
 
     def test_missing_option(self):
-        with self.assertRaisesRegexp(
+        c = config.YamlLintConfig('rules:\n'
-                config.YamlLintConfigError,
+                                  '  colons: enable\n')
-                'invalid config: missing option "max-spaces-before" '
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
-                'for rule "colons"'):
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
-            config.YamlLintConfig('rules:\n'
+
+        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(
@@ -82,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)
 
@@ -91,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)
 
@@ -115,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.assertFalse(config.validate_rule_conf(Rule, False))
-        self.assertEqual(config.validate_rule_conf(Rule, 'disable'), False)
-
         self.assertEqual(config.validate_rule_conf(Rule, {}),
                          {'level': 'error'})
-        self.assertEqual(config.validate_rule_conf(Rule, 'enable'),
-                         {'level': 'error'})
 
         config.validate_rule_conf(Rule, {'level': 'error'})
         config.validate_rule_conf(Rule, {'level': 'warning'})
@@ -133,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})
-                          config.validate_rule_conf, Rule, {'a': True})
+        config.validate_rule_conf(Rule, {'b': 0})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule, {'b': 0})
         self.assertRaises(config.YamlLintConfigError,
                           config.validate_rule_conf, Rule, {'a': 1, 'b': 0})
 
         Rule.CONF = {'choice': (True, 88, 'str')}
+        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'})
@@ -160,16 +165,37 @@ 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,
                           config.validate_rule_conf, Rule, {'choice': 'abc'})
 
+        Rule.CONF = {'multiple': ['item1', 'item2', 'item3']}
+        Rule.DEFAULT = {'multiple': ['item1']}
+        config.validate_rule_conf(Rule, {'multiple': []})
+        config.validate_rule_conf(Rule, {'multiple': ['item2']})
+        config.validate_rule_conf(Rule, {'multiple': ['item2', 'item3']})
+        config.validate_rule_conf(Rule, {})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule,
+                          {'multiple': 'item1'})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule,
+                          {'multiple': ['']})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule,
+                          {'multiple': ['item1', 4]})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule,
+                          {'multiple': ['item4']})
+
 
 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'
@@ -186,60 +212,130 @@ class ExtendedConfigTestCase(unittest.TestCase):
 
         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'
+        with tempfile.NamedTemporaryFile('w') as f:
-                                    '  colons:\n'
+            f.write('rules:\n'
-                                    '    max-spaces-before: 0\n'
+                    '  colons:\n'
-                                    '    max-spaces-after: 1\n'
+                    '    max-spaces-before: 0\n'
-                                    '  hyphens:\n'
+                    '    max-spaces-after: 1\n'
-                                    '    max-spaces-after: 2\n')
+                    '  hyphens:\n'
-        new = config.YamlLintConfig('rules:\n'
+                    '    max-spaces-after: 2\n')
-                                    '  colons: disable\n')
+            f.flush()
-        new.extend(old)
+            c = config.YamlLintConfig('extends: ' + f.name + '\n'
+                                      'rules:\n'
+                                      '  colons: disable\n')
 
-        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(new.rules['colons'], False)
+        self.assertFalse(c.rules['colons'])
-        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
+        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
 
-        self.assertEqual(len(new.enabled_rules(None)), 1)
+        self.assertEqual(len(c.enabled_rules(None)), 1)
 
     def test_extend_edit_rule(self):
-        old = config.YamlLintConfig('rules:\n'
+        with tempfile.NamedTemporaryFile('w') as f:
-                                    '  colons:\n'
+            f.write('rules:\n'
-                                    '    max-spaces-before: 0\n'
+                    '  colons:\n'
-                                    '    max-spaces-after: 1\n'
+                    '    max-spaces-before: 0\n'
-                                    '  hyphens:\n'
+                    '    max-spaces-after: 1\n'
-                                    '    max-spaces-after: 2\n')
+                    '  hyphens:\n'
-        new = config.YamlLintConfig('rules:\n'
+                    '    max-spaces-after: 2\n')
-                                    '  colons:\n'
+            f.flush()
-                                    '    max-spaces-before: 3\n'
+            c = config.YamlLintConfig('extends: ' + f.name + '\n'
-                                    '    max-spaces-after: 4\n')
+                                      'rules:\n'
-        new.extend(old)
+                                      '  colons:\n'
+                                      '    max-spaces-before: 3\n'
+                                      '    max-spaces-after: 4\n')
 
-        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(new.rules['colons']['max-spaces-before'], 3)
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 3)
-        self.assertEqual(new.rules['colons']['max-spaces-after'], 4)
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 4)
-        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
+        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
 
-        self.assertEqual(len(new.enabled_rules(None)), 2)
+        self.assertEqual(len(c.enabled_rules(None)), 2)
 
     def test_extend_reenable_rule(self):
-        old = config.YamlLintConfig('rules:\n'
+        with tempfile.NamedTemporaryFile('w') as f:
-                                    '  colons:\n'
+            f.write('rules:\n'
-                                    '    max-spaces-before: 0\n'
+                    '  colons:\n'
-                                    '    max-spaces-after: 1\n'
+                    '    max-spaces-before: 0\n'
-                                    '  hyphens: disable\n')
+                    '    max-spaces-after: 1\n'
-        new = config.YamlLintConfig('rules:\n'
+                    '  hyphens: disable\n')
-                                    '  hyphens:\n'
+            f.flush()
-                                    '    max-spaces-after: 2\n')
+            c = config.YamlLintConfig('extends: ' + f.name + '\n'
-        new.extend(old)
+                                      'rules:\n'
+                                      '  hyphens:\n'
+                                      '    max-spaces-after: 2\n')
 
-        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(new.rules['colons']['max-spaces-before'], 0)
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
-        self.assertEqual(new.rules['colons']['max-spaces-after'], 1)
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
-        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
+        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
 
-        self.assertEqual(len(new.enabled_rules(None)), 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):
@@ -271,6 +367,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')
@@ -284,6 +383,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'], 2)
+        self.assertEqual(new.rules['empty-lines']['max-start'], 42)
+        self.assertEqual(new.rules['empty-lines']['max-end'], 0)
 
 
 class IgnorePathConfigTestCase(unittest.TestCase):
@@ -338,7 +440,6 @@ class IgnorePathConfigTestCase(unittest.TestCase):
 
         shutil.rmtree(cls.wd)
 
-    @unittest.skipIf(sys.version_info < (2, 7), 'Python 2.6 not supported')
     def test_run_with_ignored_path(self):
         sys.stdout = StringIO()
         with self.assertRaises(SystemExit):
@@ -347,11 +448,13 @@ class IgnorePathConfigTestCase(unittest.TestCase):
         out = sys.stdout.getvalue()
         out = '\n'.join(sorted(out.splitlines()))
 
+        docstart = '[warning] missing document start "---" (document-start)'
         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((
+            './.yamllint:1:1: ' + docstart,
             './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,

tests/test_linter.py

@@ -15,12 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import io
-import sys
+import unittest
-try:
-    assert sys.version_info >= (2, 7)
-    import unittest
-except AssertionError:
-    import unittest2 as unittest
 
 from yamllint.config import YamlLintConfig
 from yamllint import linter

tests/test_module.py

@@ -19,17 +19,12 @@ import shutil
 import subprocess
 import tempfile
 import sys
-try:
+import unittest
-    assert sys.version_info >= (2, 7)
-    import unittest
-except AssertionError:
-    import unittest2 as unittest
 
 
 PYTHON = sys.executable or 'python'
 
 
-@unittest.skipIf(sys.version_info < (2, 7), 'Python 2.6 not supported')
 class ModuleTestCase(unittest.TestCase):
     def setUp(self):
         self.wd = tempfile.mkdtemp(prefix='yamllint-tests-')

tests/test_parser.py

@@ -14,12 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-import sys
+import unittest
-try:
-    assert sys.version_info >= (2, 7)
-    import unittest
-except AssertionError:
-    import unittest2 as unittest
 
 import yaml
 
@@ -70,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.2': 'colons: {max-spaces-after: 2}\n',
-    'example-2.4': ('colons: {max-spaces-after: 3}\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.16': 'empty-lines: {max-end: 1}\n',
-    'example-2.18': ('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.19': 'empty-lines: {max-end: 1}\n',
-    'example-2.28': ('empty-lines: {max-end: 3}\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.4': 'trailing-spaces: disable\n',
-    'example-6.5': ('trailing-spaces: disable\n'),
+    'example-6.5': 'trailing-spaces: disable\n',
-    'example-6.6': ('trailing-spaces: disable\n'),
+    'example-6.6': 'trailing-spaces: disable\n',
-    'example-6.7': ('trailing-spaces: disable\n'),
+    'example-6.7': 'trailing-spaces: disable\n',
-    'example-6.8': ('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.13': 'comments-indentation: disable\n',
-    'example-6.14': ('comments-indentation: disable\n'),
+    'example-6.14': 'comments-indentation: disable\n',
-    'example-6.23': ('colons: {max-spaces-before: 1}\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.5': 'trailing-spaces: disable\n',
-    'example-7.6': ('trailing-spaces: disable\n'),
+    'example-7.6': 'trailing-spaces: disable\n',
-    'example-7.7': ('indentation: 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.16': 'indentation: disable\n',
-    'example-7.17': ('indentation: disable\n'),
+    'example-7.17': 'indentation: disable\n',
-    'example-7.18': ('indentation: disable\n'),
+    'example-7.18': 'indentation: disable\n',
-    'example-7.19': ('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.1': 'empty-lines: {max-end: 1}\n',
-    'example-8.2': ('trailing-spaces: disable\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.6': 'empty-lines: {max-end: 1}\n',
-    'example-8.7': ('empty-lines: {max-end: 1}\n'),
+    'example-8.7': 'empty-lines: {max-end: 1}\n',
-    'example-8.8': ('trailing-spaces: disable\n'),
+    'example-8.8': 'trailing-spaces: disable\n',
-    'example-8.9': ('empty-lines: {max-end: 1}\n'),
+    'example-8.9': 'empty-lines: {max-end: 1}\n',
-    'example-8.14': ('colons: {max-spaces-before: 1}\n'),
+    'example-8.14': 'colons: {max-spaces-before: 1}\n',
-    'example-8.16': ('indentation: {spaces: 1}\n'),
+    'example-8.16': 'indentation: {spaces: 1}\n',
-    'example-8.17': ('indentation: disable\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-8.22': 'indentation: disable\n',
-    'example-10.1': ('colons: {max-spaces-before: 2}\n'),
+    'example-10.1': 'colons: {max-spaces-before: 2}\n',
-    'example-10.2': ('indentation: {indent-sequences: false}\n'),
+    'example-10.2': 'indentation: {indent-sequences: false}\n',
-    'example-10.8': ('truthy: disable\n'),
+    'example-10.8': 'truthy: disable\n',
-    'example-10.9': ('truthy: disable\n'),
+    'example-10.9': 'truthy: disable\n',
 }
 
 files = os.listdir(os.path.join(os.path.dirname(os.path.realpath(__file__)),

tests/test_yamllint_directives.py

@@ -302,3 +302,104 @@ class YamllintDirectivesTestCase(RuleTestCase):
                    '    c: [x]\n',
                    conf,
                    problem=(6, 2, 'comments-indentation'))
+
+    def test_disable_file_directive(self):
+        conf = ('comments: {min-spaces-from-content: 2}\n'
+                'comments-indentation: {}\n')
+        self.check('# yamllint disable-file\n'
+                   '---\n'
+                   '- a: 1 # comment too close\n'
+                   '  b:\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf)
+        self.check('#    yamllint disable-file\n'
+                   '---\n'
+                   '- a: 1 # comment too close\n'
+                   '  b:\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf)
+        self.check('#yamllint disable-file\n'
+                   '---\n'
+                   '- a: 1 # comment too close\n'
+                   '  b:\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf)
+        self.check('#yamllint disable-file    \n'
+                   '---\n'
+                   '- a: 1 # comment too close\n'
+                   '  b:\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf)
+        self.check('---\n'
+                   '# yamllint disable-file\n'
+                   '- a: 1 # comment too close\n'
+                   '  b:\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf,
+                   problem1=(3, 8, 'comments'),
+                   problem2=(5, 2, 'comments-indentation'))
+        self.check('# yamllint disable-file: rules cannot be specified\n'
+                   '---\n'
+                   '- a: 1 # comment too close\n'
+                   '  b:\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf,
+                   problem1=(3, 8, 'comments'),
+                   problem2=(5, 2, 'comments-indentation'))
+        self.check('AAAA yamllint disable-file\n'
+                   '---\n'
+                   '- a: 1 # comment too close\n'
+                   '  b:\n'
+                   ' # wrong indentation\n'
+                   '    c: [x]\n',
+                   conf,
+                   problem1=(1, 1, 'document-start'),
+                   problem2=(3, 8, 'comments'),
+                   problem3=(5, 2, 'comments-indentation'))
+
+    def test_disable_file_directive_not_at_first_position(self):
+        self.check('# yamllint disable-file\n'
+                   '---\n'
+                   '- bad  : colon and spaces   \n',
+                   self.conf)
+        self.check('---\n'
+                   '# yamllint disable-file\n'
+                   '- bad  : colon and spaces   \n',
+                   self.conf,
+                   problem1=(3, 7, 'colons'),
+                   problem2=(3, 26, 'trailing-spaces'))
+
+    def test_disable_file_directive_with_syntax_error(self):
+        self.check('# This file is not valid YAML (it is a Jinja template)\n'
+                   '{% if extra_info %}\n'
+                   'key1: value1\n'
+                   '{% endif %}\n'
+                   'key2: value2\n',
+                   self.conf,
+                   problem=(2, 2, 'syntax'))
+        self.check('# yamllint disable-file\n'
+                   '# This file is not valid YAML (it is a Jinja template)\n'
+                   '{% if extra_info %}\n'
+                   'key1: value1\n'
+                   '{% endif %}\n'
+                   'key2: value2\n',
+                   self.conf)
+
+    def test_disable_file_directive_with_dos_lines(self):
+        self.check('# yamllint disable-file\r\n'
+                   '---\r\n'
+                   '- bad  : colon and spaces   \r\n',
+                   self.conf)
+        self.check('# yamllint disable-file\r\n'
+                   '# This file is not valid YAML (it is a Jinja template)\r\n'
+                   '{% if extra_info %}\r\n'
+                   'key1: value1\r\n'
+                   '{% endif %}\r\n'
+                   'key2: value2\r\n',
+                   self.conf)

yamllint/__init__.py

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

yamllint/cli.py

@@ -16,24 +16,26 @@
 
 from __future__ import print_function
 
-import os
-import sys
-import platform
 import argparse
+import io
+import os
+import platform
+import sys
 
 from yamllint import APP_DESCRIPTION, APP_NAME, APP_VERSION
+from yamllint import linter
 from yamllint.config import YamlLintConfig, YamlLintConfigError
 from yamllint.linter import PROBLEM_LEVELS
-from yamllint import linter
 
 
-def find_files_recursively(items):
+def find_files_recursively(items, conf):
     for item in items:
         if os.path.isdir(item):
             for root, dirnames, filenames in os.walk(item):
-                for filename in [f for f in filenames
+                for f in filenames:
-                                 if f.endswith(('.yml', '.yaml'))]:
+                    filepath = os.path.join(root, f)
-                    yield os.path.join(root, filename)
+                    if conf.is_yaml_file(filepath):
+                        yield filepath
         else:
             yield item
 
@@ -83,11 +85,43 @@ class Format(object):
         return line
 
 
+def show_problems(problems, file, args_format, no_warn):
+    max_level = 0
+    first = True
+
+    for problem in problems:
+        max_level = max(max_level, PROBLEM_LEVELS[problem.level])
+        if no_warn and (problem.level != 'error'):
+            continue
+        if args_format == 'parsable':
+            print(Format.parsable(problem, file))
+        elif args_format == 'colored' or \
+                (args_format == 'auto' and supports_color()):
+            if first:
+                print('\033[4m%s\033[0m' % file)
+                first = False
+            print(Format.standard_color(problem, file))
+        else:
+            if first:
+                print(file)
+                first = False
+            print(Format.standard(problem, file))
+
+    if not first and args_format != 'parsable':
+        print('')
+
+    return max_level
+
+
 def run(argv=None):
     parser = argparse.ArgumentParser(prog=APP_NAME,
                                      description=APP_DESCRIPTION)
-    parser.add_argument('files', metavar='FILE_OR_DIR', nargs='+',
+    files_group = parser.add_mutually_exclusive_group(required=True)
-                        help='files to check')
+    files_group.add_argument('files', metavar='FILE_OR_DIR', nargs='*',
+                             default=(),
+                             help='files to check')
+    files_group.add_argument('-', action='store_true', dest='stdin',
+                             help='read from standard input')
     config_group = parser.add_mutually_exclusive_group()
     config_group.add_argument('-c', '--config-file', dest='config_file',
                               action='store',
@@ -102,10 +136,11 @@ def run(argv=None):
                         action='store_true',
                         help='return non-zero exit code on warnings '
                              'as well as errors')
+    parser.add_argument('--no-warnings',
+                        action='store_true',
+                        help='output only error level problems')
     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)
 
@@ -125,6 +160,10 @@ def run(argv=None):
             conf = YamlLintConfig(file=args.config_file)
         elif os.path.isfile('.yamllint'):
             conf = YamlLintConfig(file='.yamllint')
+        elif os.path.isfile('.yamllint.yaml'):
+            conf = YamlLintConfig(file='.yamllint.yaml')
+        elif os.path.isfile('.yamllint.yml'):
+            conf = YamlLintConfig(file='.yamllint.yml')
         elif os.path.isfile(user_global_config):
             conf = YamlLintConfig(file=user_global_config)
         else:
@@ -135,35 +174,28 @@ def run(argv=None):
 
     max_level = 0
 
-    for file in find_files_recursively(args.files):
+    for file in find_files_recursively(args.files, conf):
         filepath = file[2:] if file.startswith('./') else file
         try:
-            first = True
+            with io.open(file, newline='') as f:
-            with open(file) as f:
+                problems = linter.run(f, conf, filepath)
-                for problem in linter.run(f, conf, filepath):
-                    if args.format == 'parsable':
-                        print(Format.parsable(problem, file))
-                    elif args.format == 'colored' or \
-                            (args.format == 'auto' and supports_color()):
-                        if first:
-                            print('\033[4m%s\033[0m' % file)
-                            first = False
-
-                        print(Format.standard_color(problem, file))
-                    else:
-                        if first:
-                            print(file)
-                            first = False
-
-                        print(Format.standard(problem, file))
-
-                    max_level = max(max_level, PROBLEM_LEVELS[problem.level])
-
-            if not first and args.format != 'parsable':
-                print('')
         except EnvironmentError as e:
             print(e, file=sys.stderr)
             sys.exit(-1)
+        prob_level = show_problems(problems, file, args_format=args.format,
+                                   no_warn=args.no_warnings)
+        max_level = max(max_level, prob_level)
+
+    # read yaml from stdin
+    if args.stdin:
+        try:
+            problems = linter.run(sys.stdin, conf, '')
+        except EnvironmentError as e:
+            print(e, file=sys.stderr)
+            sys.exit(-1)
+        prob_level = show_problems(problems, 'stdin', args_format=args.format,
+                                   no_warn=args.no_warnings)
+        max_level = max(max_level, prob_level)
 
     if max_level == PROBLEM_LEVELS['error']:
         return_code = 1

yamllint/conf/default.yaml

@@ -1,59 +1,33 @@
 ---
 
+yaml-files:
+  - '*.yaml'
+  - '*.yml'
+  - '.yamllint'
+
 rules:
-  braces:
+  braces: enable
-    min-spaces-inside: 0
+  brackets: enable
-    max-spaces-inside: 0
+  colons: enable
-    min-spaces-inside-empty: -1
+  commas: enable
-    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
   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: enable
-  empty-lines:
+  empty-values: disable
-    max: 2
+  hyphens: enable
-    max-start: 0
+  indentation: enable
-    max-end: 0
-  quoted-strings: disable
-  empty-values:
-    forbid-in-block-mappings: false
-    forbid-in-flow-mappings: false
-  hyphens:
-    max-spaces-after: 1
-  indentation:
-    spaces: consistent
-    indent-sequences: true
-    check-multi-line-strings: false
   key-duplicates: enable
   key-ordering: disable
-  line-length:
+  line-length: enable
-    max: 80
-    allow-non-breakable-words: true
-    allow-non-breakable-inline-mappings: false
   new-line-at-end-of-file: enable
-  new-lines:
+  new-lines: enable
-    type: unix
+  octal-values: disable
-  octal-values:
+  quoted-strings: disable
-    forbid-implicit-octal: false
-    forbid-explicit-octal: false
   trailing-spaces: enable
   truthy:
     level: warning

yamllint/config.py

@@ -32,6 +32,9 @@ class YamlLintConfig(object):
 
         self.ignore = None
 
+        self.yaml_files = pathspec.PathSpec.from_lines(
+            'gitwildmatch', ['*.yaml', '*.yml', '.yamllint'])
+
         if file is not None:
             with open(file) as f:
                 content = f.read()
@@ -42,6 +45,9 @@ class YamlLintConfig(object):
     def is_file_ignored(self, filepath):
         return self.ignore and self.ignore.match_file(filepath)
 
+    def is_yaml_file(self, filepath):
+        return self.yaml_files.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 and (
@@ -74,6 +80,11 @@ class YamlLintConfig(object):
             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:
@@ -91,6 +102,15 @@ class YamlLintConfig(object):
             self.ignore = pathspec.PathSpec.from_lines(
                 'gitwildmatch', conf['ignore'].splitlines())
 
+        if 'yaml-files' in conf:
+            if not (isinstance(conf['yaml-files'], list)
+                    and all(isinstance(i, str) for i in conf['yaml-files'])):
+                raise YamlLintConfigError(
+                    'invalid config: yaml-files '
+                    'should be a list of file patterns')
+            self.yaml_files = pathspec.PathSpec.from_lines('gitwildmatch',
+                                                           conf['yaml-files'])
+
     def validate(self):
         for id in self.rules:
             try:
@@ -102,10 +122,8 @@ 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 isinstance(conf, dict):
         if ('ignore' in conf and
@@ -123,6 +141,7 @@ 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 in ('ignore', 'level'):
                 continue
@@ -130,12 +149,26 @@ def validate_rule_conf(rule, conf):
                 raise YamlLintConfigError(
                     'invalid config: unknown option "%s" for rule "%s"' %
                     (optkey, rule.ID))
+            # Example: CONF = {option: (bool, 'mixed')}
+            #          → {option: true}         → {option: mixed}
             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]))
+            # Example: CONF = {option: ['flag1', 'flag2']}
+            #          → {option: [flag1]}      → {option: [flag1, flag2]}
+            elif isinstance(options[optkey], list):
+                if (type(conf[optkey]) is not list or
+                        any(flag not in options[optkey]
+                            for flag in conf[optkey])):
+                    raise YamlLintConfigError(
+                        ('invalid config: option "%s" of "%s" should only '
+                         'contain values in %s')
+                        % (optkey, rule.ID, str(options[optkey])))
+            # Example: CONF = {option: int}
+            #          → {option: 42}
             else:
                 if not isinstance(conf[optkey], options[optkey]):
                     raise YamlLintConfigError(
@@ -143,9 +176,7 @@ def validate_rule_conf(rule, conf):
                         % (optkey, rule.ID, options[optkey].__name__))
         for optkey in options:
             if optkey not in conf:
-                raise YamlLintConfigError(
+                conf[optkey] = options_default[optkey]
-                    'invalid config: missing option "%s" for rule "%s"' %
-                    (optkey, rule.ID))
     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):
@@ -75,10 +75,10 @@ def get_cosmetic_problems(buffer, conf, filepath):
     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:
@@ -180,7 +180,7 @@ def get_syntax_error(buffer):
     except yaml.error.MarkedYAMLError as e:
         problem = LintProblem(e.problem_mark.line + 1,
                               e.problem_mark.column + 1,
-                              'syntax error: ' + e.problem)
+                              'syntax error: ' + e.problem + ' (syntax)')
         problem.level = 'error'
         return problem
 
@@ -189,6 +189,10 @@ def _run(buffer, conf, filepath):
     assert hasattr(buffer, '__getitem__'), \
         '_run() argument must be a buffer, not a stream'
 
+    first_line = next(parser.line_generator(buffer)).content
+    if re.match(r'^#\s*yamllint disable-file\s*$', first_line):
+        return
+
     # If the document contains a syntax error, save it and yield it at the
     # right line
     syntax_error = get_syntax_error(buffer)

yamllint/parser.py

@@ -77,7 +77,10 @@ def line_generator(buffer):
     cur = 0
     next = buffer.find('\n')
     while next != -1:
-        yield Line(line_no, buffer, start=cur, end=next)
+        if next > 0 and buffer[next - 1] == '\r':
+            yield Line(line_no, buffer, start=cur, end=next - 1)
+        else:
+            yield Line(line_no, buffer, start=cur, end=next)
         cur = next + 1
         next = buffer.find('\n', cur)
         line_no += 1

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

@@ -72,13 +72,15 @@ Use this rule to control the number of spaces before and after colons (``:``).
 
 import yaml
 
-from yamllint.rules.common import spaces_after, spaces_before, is_explicit_key
+from yamllint.rules.common import is_explicit_key, spaces_after, spaces_before
 
 
 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
+        if text_start < len(comment.buffer):
-                comment.buffer[text_start] not in (' ', '\n', '\0')):
+            if (conf['ignore-shebangs'] and
-            yield LintProblem(comment.line_no,
+                    comment.line_no == 1 and
-                              comment.column_no + text_start - comment.pointer,
+                    comment.column_no == 1 and
-                              'missing starting space in comment')
+                    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,6 +82,7 @@ from yamllint.linter import LintProblem
 ID = 'document-end'
 TYPE = 'token'
 CONF = {'present': bool}
+DEFAULT = {'present': True}
 
 
 def check(conf, token, prev, next, nextnext, context):

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,32 +58,45 @@ TYPE = 'line'
 CONF = {'max': int,
         'max-start': int,
         'max-end': int}
+DEFAULT = {'max': 2,
+           'max-start': 0,
+           'max-end': 0}
 
 
 def check(conf, line):
     if line.start == line.end and line.end < len(line.buffer):
         # Only alert on the last blank line of a series
-        if (line.end < len(line.buffer) - 1 and
+        if (line.end + 2 <= len(line.buffer) and
-                line.buffer[line.end + 1] == '\n'):
+                line.buffer[line.end:line.end + 2] == '\n\n'):
+            return
+        elif (line.end + 4 <= len(line.buffer) and
+              line.buffer[line.end:line.end + 4] == '\r\n\r\n'):
             return
 
         blank_lines = 0
 
-        while (line.start > blank_lines and
+        start = line.start
-               line.buffer[line.start - blank_lines - 1] == '\n'):
+        while start >= 2 and line.buffer[start - 2:start] == '\r\n':
             blank_lines += 1
+            start -= 2
+        while start >= 1 and line.buffer[start - 1] == '\n':
+            blank_lines += 1
+            start -= 1
 
         max = conf['max']
 
         # Special case: start of document
-        if line.start - blank_lines == 0:
+        if start == 0:
             blank_lines += 1  # first line doesn't have a preceding \n
             max = conf['max-start']
 
         # Special case: end of document
         # NOTE: The last line of a file is always supposed to end with a new
         # line. See POSIX definition of a line at:
-        if line.end == len(line.buffer) - 1 and line.buffer[line.end] == '\n':
+        if ((line.end == len(line.buffer) - 1 and
+             line.buffer[line.end] == '\n') or
+            (line.end == len(line.buffer) - 2 and
+             line.buffer[line.end:line.end + 2] == '\r\n')):
             # Allow the exception of the one-byte file containing '\n'
             if line.end == 0:
                 return

yamllint/rules/empty_values.py

@@ -75,6 +75,8 @@ ID = 'empty-values'
 TYPE = 'token'
 CONF = {'forbid-in-block-mappings': bool,
         'forbid-in-flow-mappings': bool}
+DEFAULT = {'forbid-in-block-mappings': True,
+           'forbid-in-flow-mappings': True}
 
 
 def check(conf, token, prev, next, nextnext, context):

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

@@ -193,7 +193,7 @@ Use this rule to control the indentation.
 import yaml
 
 from yamllint.linter import LintProblem
-from yamllint.rules.common import is_explicit_key, get_real_end_line
+from yamllint.rules.common import get_real_end_line, is_explicit_key
 
 
 ID = 'indentation'
@@ -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')

yamllint/rules/key_duplicates.py

@@ -61,7 +61,6 @@ from yamllint.linter import LintProblem
 
 ID = 'key-duplicates'
 TYPE = 'token'
-CONF = {}
 
 MAP, SEQ = range(2)
 

yamllint/rules/key_ordering.py

@@ -72,7 +72,6 @@ from yamllint.linter import LintProblem
 
 ID = 'key-ordering'
 TYPE = 'token'
-CONF = {}
 
 MAP, SEQ = range(2)
 

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,15 +30,17 @@ from yamllint.linter import LintProblem
 ID = 'new-lines'
 TYPE = 'line'
 CONF = {'type': ('unix', 'dos')}
+DEFAULT = {'type': 'unix'}
 
 
 def check(conf, line):
     if line.start == 0 and len(line.buffer) > line.end:
         if conf['type'] == 'dos':
-            if line.buffer[line.end - 1:line.end + 1] != '\r\n':
+            if (line.end + 2 > len(line.buffer) or
+                    line.buffer[line.end:line.end + 2] != '\r\n'):
                 yield LintProblem(1, line.end - line.start + 1,
                                   'wrong new line character: expected \\r\\n')
         else:
-            if line.end > 0 and line.buffer[line.end - 1] == '\r':
+            if line.buffer[line.end] == '\r':
-                yield LintProblem(1, line.end - line.start,
+                yield LintProblem(1, line.end - line.start + 1,
                                   'wrong new line character: expected \\n')

yamllint/rules/octal_values.py

@@ -66,6 +66,8 @@ ID = 'octal-values'
 TYPE = 'token'
 CONF = {'forbid-implicit-octal': bool,
         'forbid-explicit-octal': bool}
+DEFAULT = {'forbid-implicit-octal': True,
+           'forbid-explicit-octal': True}
 
 
 def check(conf, token, prev, next, nextnext, context):

yamllint/rules/quoted_strings.py

@@ -15,15 +15,23 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Use this rule to forbid any string values that are not quoted.
+Use this rule to forbid any string values that are not quoted, or to prevent
-You can also enforce the type of the quote used using the ``quote-type`` option
+quoted strings without needing it. You can also enforce the type of the quote
-(``single``, ``double`` or ``any``).
+used.
+
+.. rubric:: Options
+
+* ``quote-type`` defines allowed quotes: ``single``, ``double`` or ``any``
+  (default).
+* ``required`` defines whether using quotes in string values is required
+  (``true``, default) or not (``false``), or only allowed when really needed
+  (``only-when-needed``).
 
 **Note**: Multi-line strings (with ``|`` or ``>``) will not be checked.
 
 .. rubric:: Examples
 
-#. With ``quoted-strings: {quote-type: any}``
+#. With ``quoted-strings: {quote-type: any, required: true}``
 
    the following code snippet would **PASS**:
    ::
@@ -37,6 +45,24 @@ You can also enforce the type of the quote used using the ``quote-type`` option
    ::
 
     foo: bar
+
+#. With ``quoted-strings: {quote-type: single, required: only-when-needed}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    foo: bar
+    bar: foo
+    not_number: '123'
+    not_boolean: 'true'
+    not_comment: '# comment'
+    not_list: '[1, 2, 3]'
+    not_map: '{a: 1, b: 2}'
+
+   the following code snippet would **FAIL**:
+   ::
+
+    foo: 'bar'
 """
 
 import yaml
@@ -45,33 +71,76 @@ from yamllint.linter import LintProblem
 
 ID = 'quoted-strings'
 TYPE = 'token'
-CONF = {'quote-type': ('any', 'single', 'double')}
+CONF = {'quote-type': ('any', 'single', 'double'),
+        'required': (True, False, 'only-when-needed')}
+DEFAULT = {'quote-type': 'any',
+           'required': True}
+
+DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str'
+START_TOKENS = {'#', '*', '!', '?', '@', '`', '&',
+                ',', '-', '{', '}', '[', ']', ':'}
+
+
+def quote_match(quote_type, token_style):
+    return ((quote_type == 'any') or
+            (quote_type == 'single' and token_style == "'") or
+            (quote_type == 'double' and token_style == '"'))
 
 
 def check(conf, token, prev, next, nextnext, context):
-    quote_type = conf['quote-type']
+    if not (isinstance(token, yaml.tokens.ScalarToken) and
-
-    if (isinstance(token, yaml.tokens.ScalarToken) and
             isinstance(prev, (yaml.ValueToken, yaml.TagToken))):
-        # Ignore explicit types, e.g. !!str testtest or !!int 42
+        return
-        if (prev and isinstance(prev, yaml.tokens.TagToken) and
-                prev.value[0] == '!!'):
-            return
 
-        # Ignore numbers, booleans, etc.
+    # Ignore explicit types, e.g. !!str testtest or !!int 42
-        resolver = yaml.resolver.Resolver()
+    if (prev and isinstance(prev, yaml.tokens.TagToken) and
-        if resolver.resolve(yaml.nodes.ScalarNode, token.value,
+            prev.value[0] == '!!'):
-                            (True, False)) != 'tag:yaml.org,2002:str':
+        return
-            return
 
-        # Ignore multi-line strings
+    # Ignore numbers, booleans, etc.
-        if (not token.plain) and (token.style == "|" or token.style == ">"):
+    resolver = yaml.resolver.Resolver()
-            return
+    tag = resolver.resolve(yaml.nodes.ScalarNode, token.value, (True, False))
+    if token.plain and tag != DEFAULT_SCALAR_TAG:
+        return
 
-        if ((quote_type == 'single' and token.style != "'") or
+    # Ignore multi-line strings
-                (quote_type == 'double' and token.style != '"') or
+    if (not token.plain) and (token.style == "|" or token.style == ">"):
-                (quote_type == 'any' and token.style is None)):
+        return
-            yield LintProblem(
+
-                token.start_mark.line + 1,
+    quote_type = conf['quote-type']
-                token.start_mark.column + 1,
+    required = conf['required']
-                "string value is not quoted with %s quotes" % (quote_type))
+
+    # Completely relaxed about quotes (same as the rule being disabled)
+    if required is False and quote_type == 'any':
+        return
+
+    msg = None
+    if required is True:
+
+        # Quotes are mandatory and need to match config
+        if token.style is None or not quote_match(quote_type, token.style):
+            msg = "string value is not quoted with %s quotes" % (quote_type)
+
+    elif required is False:
+
+        # Quotes are not mandatory but when used need to match config
+        if token.style and not quote_match(quote_type, token.style):
+            msg = "string value is not quoted with %s quotes" % (quote_type)
+
+    elif not token.plain:
+
+        # Quotes are disallowed when not needed
+        if (tag == DEFAULT_SCALAR_TAG and token.value
+                and token.value[0] not in START_TOKENS):
+            msg = "string value is redundantly quoted with %s quotes" % (
+                quote_type)
+
+        # But when used need to match config
+        elif token.style and not quote_match(quote_type, token.style):
+            msg = "string value is not quoted with %s quotes" % (quote_type)
+
+    if msg is not None:
+        yield LintProblem(
+            token.start_mark.line + 1,
+            token.start_mark.column + 1,
+            msg)

yamllint/rules/truthy.py

@@ -15,13 +15,22 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Use this rule to forbid non-explictly typed truthy values other than ``true``
+Use this rule to forbid non-explictly typed truthy values other than allowed
-and ``false``, for example ``YES``, ``False`` and ``off``.
+ones (by default: ``true`` and ``false``), for example ``YES`` or ``off``.
 
 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:: Options
+
+* ``allowed-values`` defines the list of truthy values which will be ignored
+  during linting. The default is ``['true', 'false']``, but can be changed to
+  any list containing: ``'TRUE'``, ``'True'``,  ``'true'``, ``'FALSE'``,
+  ``'False'``, ``'false'``, ``'YES'``, ``'Yes'``, ``'yes'``, ``'NO'``,
+  ``'No'``, ``'no'``, ``'ON'``, ``'On'``, ``'on'``, ``'OFF'``, ``'Off'``,
+  ``'off'``.
+
 .. rubric:: Examples
 
 #. With ``truthy: {}``
@@ -63,30 +72,55 @@ This can be useful to prevent surprises from YAML parsers transforming
     yes:  1
     on:   2
     True: 3
+
+#. With ``truthy: {allowed-values: ["yes", "no"]}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    - yes
+    - no
+    - "true"
+    - 'false'
+    - foo
+    - bar
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - true
+    - false
+    - on
+    - off
 """
 
 import yaml
 
 from yamllint.linter import LintProblem
 
-ID = 'truthy'
-TYPE = 'token'
-CONF = {}
 
 TRUTHY = ['YES', 'Yes', 'yes',
           'NO', 'No', 'no',
-          'TRUE', 'True',  # 'true' is a boolean
+          'TRUE', 'True', 'true',
-          'FALSE', 'False',  # 'false' is a boolean
+          'FALSE', 'False', 'false',
           'ON', 'On', 'on',
           'OFF', 'Off', 'off']
 
 
+ID = 'truthy'
+TYPE = 'token'
+CONF = {'allowed-values': list(TRUTHY)}
+DEFAULT = {'allowed-values': ['true', 'false']}
+
+
 def check(conf, token, prev, next, nextnext, context):
     if prev and isinstance(prev, yaml.tokens.TagToken):
         return
 
     if isinstance(token, yaml.tokens.ScalarToken):
-        if token.value in TRUTHY and token.style is None:
+        if (token.value in (set(TRUTHY) - set(conf['allowed-values'])) and
+                token.style is None):
             yield LintProblem(token.start_mark.line + 1,
                               token.start_mark.column + 1,
-                              "truthy value should be true or false")
+                              "truthy value should be one of [" +
+                              ", ".join(sorted(conf['allowed-values'])) + "]")