yamllint version 1.22.1

Change implementation of `required: only-when-needed`, because
maintaining a list of `START_TOKENS` and just looking at the first
character of string values has proven to be partially broken.

Cf. discussion at
https://github.com/adrienverge/yamllint/pull/246#issuecomment-612354097.

Fixes https://github.com/adrienverge/yamllint/issues/242 and
https://github.com/adrienverge/yamllint/pull/244.

.gitignore

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

.pre-commit-hooks.yaml

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

.travis.yml

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

CHANGELOG.rst

@@ -0,0 +1,139 @@
+Changelog
+=========
+
+1.22.1 (2020-04-15)
+-------------------
+
+- Fix ``quoted-strings`` rule with ``only-when-needed`` on corner cases
+
+1.22.0 (2020-04-13)
+-------------------
+
+- Add ``check-keys`` option to the ``truthy`` rule
+- Fix ``quoted-strings`` rule not working on sequences items
+- Sunset Python 2
+
+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``
+- Add a new ``-f colored`` option
+- Update documentation about colored output when run from CLI
+
+1.12.1 (2018-10-17)
+-------------------
+
+- Fix the ``quoted-strings`` rule, broken implementation
+- Fix missing documentation for the ``quoted-strings`` rule
+
+1.12.0 (2018-10-04)
+-------------------
+
+- Add a new ``quoted-strings`` rule
+- Update installation documentation for pip, CentOS, Debian, Ubuntu, Mac OS
+
+1.11.1 (2018-04-06)
+-------------------
+
+- Handle merge keys (``<<``) in the ``key-duplicates`` rule
+- Update documentation about pre-commit
+- Make examples for ``ignore`` rule clearer
+- Clarify documentation on the 'truthy' rule
+- Fix crash in parser due to a change in PyYAML > 3.12
+
+1.11.0 (2018-02-21)
+-------------------
+
+- Add a new ``octal-values`` rule
+
+1.10.0 (2017-11-05)
+-------------------
+
+- Fix colored output on Windows
+- Check documentation compilation on continuous integration
+- Add a new ``empty-values`` rule
+- Make sure test files are included in dist bundle
+- Tests: Use en_US.UTF-8 locale when C.UTF-8 not available
+- Tests: Dynamically detect Python executable path
+
+1.9.0 (2017-10-16)
+------------------
+
+- Add a new ``key-ordering`` rule
+- Fix indentation rule for key following empty list
+
+1.8.2 (2017-10-10)
+------------------
+
+- Be clearer about the ``ignore`` conf type
+- Update pre-commit hook file
+- Add documentation for pre-commit
+
+1.8.1 (2017-07-04)
+------------------
+
+- Require pathspec >= 0.5.3
+- Support Python 2.6
+- Add a changelog
+
+1.8.0 (2017-06-28)
+------------------
+
+- Refactor argparse with mutually_exclusive_group
+- Add support to ignore paths in configuration

MANIFEST.in

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

README.rst

@@ -3,8 +3,9 @@ yamllint
 
 A linter for YAML files.
 
-yamllint does not only check for syntax validity, but for common cosmetic
+yamllint does not only check for syntax validity, but for weirdnesses like key
-conventions such as lines length, trailing spaces, indentation, etc.
+repetition and cosmetic problems such as lines length, trailing spaces,
+indentation, etc.
 
 .. image::
    https://travis-ci.org/adrienverge/yamllint.svg?branch=master
@@ -15,18 +16,22 @@ conventions such as lines length, trailing spaces, indentation, etc.
    :target: https://coveralls.io/github/adrienverge/yamllint?branch=master
    :alt: Code coverage status
 .. image:: https://readthedocs.org/projects/yamllint/badge/?version=latest
-   :target: http://yamllint.readthedocs.org/en/latest/?badge=latest
+   :target: https://yamllint.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation status
 
 Written in Python (compatible with Python 2 & 3).
 
+⚠ Python 2 upstream support stopped on January 1, 2020. yamllint will keep
+best-effort support for Python 2.7 until January 1, 2021. Passed that date,
+yamllint will drop all Python 2-related code.
+
 Documentation
 -------------
 
-http://yamllint.readthedocs.org/
+https://yamllint.readthedocs.io/
 
-Short overview
+Overview
---------------
+--------
 
 Screenshot
 ^^^^^^^^^^
@@ -37,9 +42,15 @@ Screenshot
 Installation
 ^^^^^^^^^^^^
 
+Using pip, the Python package manager:
+
 .. code:: bash
 
- sudo pip install yamllint
+ 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
 ^^^^^
@@ -56,10 +67,78 @@ Usage
 
 .. code:: bash
 
+ # Use a pre-defined lint configuration
+ yamllint -d relaxed file.yaml
+
  # Use a custom lint configuration
- yamllint -c ~/myconfig file.yml
+ yamllint -c /path/to/myconfig file-to-lint.yaml
 
 .. code:: bash
 
  # Output a parsable format (for syntax checking in editors like Vim, emacs...)
- yamllint -f parsable file.yml
+ yamllint -f parsable file.yaml
+
+`Read more in the complete documentation! <https://yamllint.readthedocs.io/>`_
+
+Features
+^^^^^^^^
+
+Here is a yamllint configuration file example:
+
+.. code:: yaml
+
+ extends: default
+
+ rules:
+   # 80 chars should be enough, but don't fail if a line is longer
+   line-length:
+     max: 80
+     level: warning
+
+   # don't bother me with this rule
+   indentation: disable
+
+Within a YAML file, special comments can be used to disable checks for a single
+line:
+
+.. code:: yaml
+
+ This line is waaaaaaaaaay too long  # yamllint disable-line
+
+or for a whole block:
+
+.. code:: yaml
+
+ # yamllint disable rule:colons
+ - Lorem       : ipsum
+   dolor       : sit amet,
+   consectetur : adipiscing elit
+ # yamllint enable
+
+Specific files can be ignored (totally or for some rules only) using a
+``.gitignore``-style pattern:
+
+.. code:: yaml
+
+ # For all rules
+ ignore: |
+   *.dont-lint-me.yaml
+   /bin/
+   !/bin/*.lint-me-anyway.yaml
+
+ rules:
+   key-duplicates:
+     ignore: |
+       generated
+       *.template.yaml
+   trailing-spaces:
+     ignore: |
+       *.ignore-trailing-spaces.yaml
+       /ascii-art/*
+
+`Read more in the complete documentation! <https://yamllint.readthedocs.io/>`_
+
+License
+-------
+
+`GPL version 3 <LICENSE>`_

docs/conf.py

@@ -4,6 +4,7 @@
 
 import sys
 import os
+from unittest.mock import MagicMock
 
 sys.path.insert(0, os.path.abspath('..'))  # noqa
 
@@ -38,6 +39,17 @@ htmlhelp_basename = 'yamllintdoc'
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'yamllint', u'yamllint Documentation',
+    ('index', 'yamllint', '', [u'Adrien Vergé'], 1)
-     [u'Adrien Vergé'], 1)
 ]
+
+# -- Build with sphinx automodule without needing to install third-party libs
+
+
+class Mock(MagicMock):
+    @classmethod
+    def __getattr__(cls, name):
+        return MagicMock()
+
+
+MOCK_MODULES = ['pathspec', 'yaml']
+sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)

docs/configuration.rst

@@ -1,33 +1,54 @@
 Configuration
 =============
 
-yamllint uses a set of *rules* to check sources files for problems. Each rule is
+yamllint uses a set of :doc:`rules <rules>` to check source files for problems.
-independent from the others, and can be enabled, disabled or tweaked. All these
+Each rule is independent from the others, and can be enabled, disabled or
-settings can be gathered in a configuration file.
+tweaked. All these settings can be gathered in a configuration file.
 
-To use a custom configuration file, either name it ``.yamllint`` in your working
+To use a custom configuration file, use the ``-c`` option:
-directory, or use the ``-c`` option:
 
-::
+.. code:: bash
 
- yamllint -c ~/myconfig file.yml
+ yamllint -c /path/to/myconfig file-to-lint.yaml
+
+If ``-c`` is not provided, yamllint will look for a configuration file in the
+following locations (by order of preference):
+
+- ``.yamllint``, ``.yamllint.yaml`` or ``.yamllint.yml`` in the current working
+  directory
+- ``$XDG_CONFIG_HOME/yamllint/config``
+- ``~/.config/yamllint/config``
+
+Finally if no config file is found, the default configuration is applied.
 
 Default configuration
 ---------------------
 
 Unless told otherwise, yamllint uses its ``default`` configuration:
 
-.. literalinclude:: ../yamllint/conf/default.yml
+.. literalinclude:: ../yamllint/conf/default.yaml
    :language: yaml
 
 Details on rules can be found on :doc:`the rules page <rules>`.
 
+There is another pre-defined configuration named ``relaxed``. As its name
+suggests, it is more tolerant:
+
+.. literalinclude:: ../yamllint/conf/relaxed.yaml
+   :language: yaml
+
+It can be chosen using:
+
+.. code:: bash
+
+ yamllint -d relaxed file.yml
+
 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:
@@ -50,7 +71,7 @@ strict on block sequences indentation:
  extends: default
 
  rules:
-   # 80 should be enough, but don't fail if a line is longer
+   # 80 chars should be enough, but don't fail if a line is longer
    line-length:
      max: 80
      level: warning
@@ -63,12 +84,107 @@ strict on block sequences indentation:
    indentation:
      indent-sequences: whatever
 
+Custom configuration without a config file
+------------------------------------------
+
+It is possible -- although not recommended -- to pass custom configuration
+options to yamllint with the ``-d`` (short for ``--config-data``) option.
+
+Its content can either be the name of a pre-defined conf (example: ``default``
+or ``relaxed``) or a serialized YAML object describing the configuration.
+
+For instance:
+
+.. code:: bash
+
+ yamllint -d "{extends: relaxed, rules: {line-length: {max: 120}}}" file.yaml
+
 Errors and warnings
 -------------------
 
 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).
 
-In both cases, the script will output them (with different colors when using the
+By default the script will exit with a return code ``1`` *only when* there is
-``standard`` output format), but the exit code can be different. More precisely,
+one or more error(s).
-the script will exit will a failure code *only when* there is one or more
+
-error(s).
+However if strict mode is enabled with the ``-s`` (or ``--strict``) option, the
+return code will be:
+
+ * ``0`` if no errors or warnings occur
+ * ``1`` if one or more errors occur
+ * ``2`` if no errors occur, but one or more warnings occur
+
+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
+--------------
+
+It is possible to exclude specific files or directories, so that the linter
+doesn't process them.
+
+You can either totally ignore files (they won't be looked at):
+
+.. code-block:: yaml
+
+ extends: default
+
+ ignore: |
+   /this/specific/file.yaml
+   all/this/directory/
+   *.template.yaml
+
+or ignore paths only for specific rules:
+
+.. code-block:: yaml
+
+ extends: default
+
+ rules:
+   trailing-spaces:
+     ignore: |
+       /this-file-has-trailing-spaces-but-it-is-OK.yaml
+       /generated/*.yaml
+
+Note that this ``.gitignore``-style path pattern allows complex path
+exclusion/inclusion, see the `pathspec README file
+<https://pypi.python.org/pypi/pathspec>`_ for more details.
+Here is a more complex example:
+
+.. code-block:: yaml
+
+ # For all rules
+ ignore: |
+   *.dont-lint-me.yaml
+   /bin/
+   !/bin/*.lint-me-anyway.yaml
+
+ extends: default
+
+ rules:
+   key-duplicates:
+     ignore: |
+       generated
+       *.template.yaml
+   trailing-spaces:
+     ignore: |
+       *.ignore-trailing-spaces.yaml
+       ascii-art/*

docs/disable_with_comments.rst

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

@@ -1,10 +1,7 @@
 yamllint documentation
 ======================
 
-A linter for YAML files.
+.. automodule:: yamllint
-
-yamllint does not only check for syntax validity, but for common cosmetic
-conventions such as lines length, trailing spaces, indentation, etc.
 
 Screenshot
 ----------
@@ -26,5 +23,7 @@ Table of contents
    quickstart
    configuration
    rules
+   disable_with_comments
    development
    text_editors
+   integration

docs/integration.rst

@@ -0,0 +1,19 @@
+Integration with other software
+===============================
+
+Integration with pre-commit
+---------------------------
+
+You can integrate yamllint in `pre-commit <http://pre-commit.com/>`_ tool.
+Here is an example, to add in your .pre-commit-config.yaml
+
+.. code:: yaml
+
+  ---
+  # Update the 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
+    rev: v1.17.0
+    hooks:
+      - id: yamllint
+        args: [-c=/path/to/.yamllint]

docs/quickstart.rst

@@ -4,35 +4,71 @@ Quickstart
 Installing yamllint
 -------------------
 
-First, install yamllint. The easiest way is to use pip, the Python package
+On Fedora / CentOS (note: `EPEL <https://fedoraproject.org/wiki/EPEL>`_ is
-manager:
+required on CentOS):
 
-::
+.. code:: bash
 
- sudo pip install yamllint
+ 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
+
+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
+
+ pip install --user yamllint
 
 If you prefer installing from source, you can run, from the source directory:
 
-::
+.. code:: bash
 
  python setup.py sdist
- sudo pip install dist/yamllint-*.tar.gz
+ pip install --user dist/yamllint-*.tar.gz
 
 Running yamllint
 ----------------
 
 Basic usage:
 
-::
+.. code:: bash
 
  yamllint file.yml other-file.yaml
 
 You can also lint all YAML files in a whole directory:
 
-::
+.. code:: bash
 
  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):
 
 ::
@@ -51,6 +87,10 @@ The output will look like (colors are not displayed here):
    10:1      error    too many blank lines (4 > 2)  (empty-lines)
    11:4      error    too many spaces inside braces  (braces)
 
+By default, the output of yamllint is colored when run from a terminal, and
+pure text in other cases. Add the ``-f standard`` arguments to force
+non-colored output. Use the ``-f colored`` arguments to force colored output.
+
 Add the ``-f parsable`` arguments if you need an output format parsable by a
 machine (for instance for :doc:`syntax highlighting in text editors
 <text_editors>`). The output will then look like:
@@ -65,9 +105,9 @@ If you have a custom linting configuration file (see :doc:`how to configure
 yamllint <configuration>`), it can be passed to yamllint using the ``-c``
 option:
 
-::
+.. code:: bash
 
- yamllint -c ~/myconfig file.yml
+ yamllint -c ~/myconfig file.yaml
 
 .. note::
 

docs/rules.rst

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

docs/text_editors.rst

@@ -9,8 +9,12 @@ text editor.
 Vim
 ---
 
-Assuming that the `syntastic <https://github.com/scrooloose/syntastic>`_ plugin
+Assuming that the `ALE <https://github.com/w0rp/ale>`_ plugin is
-is installed, add to your ``.vimrc``:
+installed, yamllint is supported by default. It is automatically enabled when
+editing YAML files.
+
+If you instead use the `syntastic <https://github.com/scrooloose/syntastic>`_
+plugin, add this to your ``.vimrc``:
 
 ::
 
@@ -20,16 +24,14 @@ Neovim
 ------
 
 Assuming that the `neomake <https://github.com/benekastah/neomake>`_ plugin is
-installed, add to your ``.config/nvim/init.vim``:
+installed, yamllint is supported by default. It is automatically enabled when
+editing YAML files.
 
-::
+Emacs
+-----
 
- if executable('yamllint')
+If you are `flycheck <https://github.com/flycheck/flycheck>`_ user, you can use
-   let g:neomake_yaml_yamllint_maker = {
+`flycheck-yamllint <https://github.com/krzysztof-magosa/flycheck-yamllint>`_ integration.
-     \ 'args': ['-f', 'parsable'],
-     \ 'errorformat': '%E%f:%l:%c: [error] %m,%W%f:%l:%c: [warning] %m' }
-   let g:neomake_yaml_enabled_makers = ['yamllint']
- endif
 
 Other text editors
 ------------------

setup.cfg

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

setup.py

@@ -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,23 +29,28 @@ 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 :: 4 - Beta',
+        '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',
         'Topic :: Software Development :: Testing',
     ],
 
-    packages=find_packages(),
+    packages=find_packages(exclude=['tests', 'tests.*']),
     entry_points={'console_scripts': ['yamllint=yamllint.cli:run']},
-    package_data={'yamllint': ['conf/*.yml']},
+    package_data={'yamllint': ['conf/*.yaml']},
-    install_requires=['pyyaml'],
+    install_requires=['pathspec >=0.5.3', 'pyyaml'],
-    tests_require=['nose'],
+    test_suite='tests',
-    test_suite='nose.collector',
 )

tests/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2016 Adrien Vergé
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import locale
+
+
+locale.setlocale(locale.LC_ALL, 'C')

tests/common.py

@@ -14,6 +14,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import os
+import tempfile
 import unittest
 
 import yaml
@@ -49,3 +51,21 @@ class RuleTestCase(unittest.TestCase):
 
         real_problems = list(linter.run(source, self.build_fake_config(conf)))
         self.assertEqual(real_problems, expected_problems)
+
+
+def build_temp_workspace(files):
+    tempdir = tempfile.mkdtemp(prefix='yamllint-tests-')
+
+    for path, content in files.items():
+        path = os.path.join(tempdir, path)
+        if not os.path.exists(os.path.dirname(path)):
+            os.makedirs(os.path.dirname(path))
+
+        if type(content) is list:
+            os.mkdir(path)
+        else:
+            mode = 'wb' if isinstance(content, bytes) else 'w'
+            with open(path, mode) as f:
+                f.write(content)
+
+    return tempdir

tests/rules/test_braces.py

@@ -32,11 +32,19 @@ class ColonTestCase(RuleTestCase):
                    'dict7: {   a: 1, b, c: 3 }\n', conf)
 
     def test_min_spaces(self):
-        conf = 'braces: {max-spaces-inside: -1, min-spaces-inside: 0}'
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: 0\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'dict: {}\n', conf)
 
-        conf = 'braces: {max-spaces-inside: -1, min-spaces-inside: 1}'
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: 1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'dict: {}\n', conf, problem=(2, 8))
         self.check('---\n'
@@ -52,7 +60,11 @@ class ColonTestCase(RuleTestCase):
                    '  b\n'
                    '}\n', conf)
 
-        conf = 'braces: {max-spaces-inside: -1, min-spaces-inside: 3}'
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: 3\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'dict: { a: 1, b }\n', conf,
                    problem1=(2, 9), problem2=(2, 17))
@@ -60,7 +72,11 @@ class ColonTestCase(RuleTestCase):
                    'dict: {   a: 1, b   }\n', conf)
 
     def test_max_spaces(self):
-        conf = 'braces: {max-spaces-inside: 0, min-spaces-inside: -1}'
+        conf = ('braces:\n'
+                '  max-spaces-inside: 0\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'dict: {}\n', conf)
         self.check('---\n'
@@ -79,7 +95,11 @@ class ColonTestCase(RuleTestCase):
                    '  b\n'
                    '}\n', conf)
 
-        conf = 'braces: {max-spaces-inside: 3, min-spaces-inside: -1}'
+        conf = ('braces:\n'
+                '  max-spaces-inside: 3\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'dict: {   a: 1, b   }\n', conf)
         self.check('---\n'
@@ -87,7 +107,11 @@ class ColonTestCase(RuleTestCase):
                    problem1=(2, 11), problem2=(2, 23))
 
     def test_min_and_max_spaces(self):
-        conf = 'braces: {max-spaces-inside: 0, min-spaces-inside: 0}'
+        conf = ('braces:\n'
+                '  max-spaces-inside: 0\n'
+                '  min-spaces-inside: 0\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'dict: {}\n', conf)
         self.check('---\n'
@@ -95,14 +119,169 @@ class ColonTestCase(RuleTestCase):
         self.check('---\n'
                    'dict: {   a: 1, b}\n', conf, problem=(2, 10))
 
-        conf = 'braces: {max-spaces-inside: 1, min-spaces-inside: 1}'
+        conf = ('braces:\n'
+                '  max-spaces-inside: 1\n'
+                '  min-spaces-inside: 1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'dict: {a: 1, b, c: 3 }\n', conf, problem=(2, 8))
 
-        conf = 'braces: {max-spaces-inside: 2, min-spaces-inside: 0}'
+        conf = ('braces:\n'
+                '  max-spaces-inside: 2\n'
+                '  min-spaces-inside: 0\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'dict: {a: 1, b, c: 3 }\n', conf)
         self.check('---\n'
                    'dict: {  a: 1, b, c: 3 }\n', conf)
         self.check('---\n'
                    'dict: {   a: 1, b, c: 3 }\n', conf, problem=(2, 10))
+
+    def test_min_spaces_empty(self):
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 0\n'
+                '  min-spaces-inside-empty: 0\n')
+        self.check('---\n'
+                   'array: {}\n', conf)
+
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: 1\n')
+        self.check('---\n'
+                   'array: {}\n', conf, problem=(2, 9))
+        self.check('---\n'
+                   'array: { }\n', conf)
+
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: 3\n')
+        self.check('---\n'
+                   'array: {}\n', conf, problem=(2, 9))
+        self.check('---\n'
+                   'array: {   }\n', conf)
+
+    def test_max_spaces_empty(self):
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 0\n'
+                '  min-spaces-inside-empty: -1\n')
+        self.check('---\n'
+                   'array: {}\n', conf)
+        self.check('---\n'
+                   'array: { }\n', conf, problem=(2, 9))
+
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 1\n'
+                '  min-spaces-inside-empty: -1\n')
+        self.check('---\n'
+                   'array: {}\n', conf)
+        self.check('---\n'
+                   'array: { }\n', conf)
+        self.check('---\n'
+                   'array: {  }\n', conf, problem=(2, 10))
+
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 3\n'
+                '  min-spaces-inside-empty: -1\n')
+        self.check('---\n'
+                   'array: {}\n', conf)
+        self.check('---\n'
+                   'array: {   }\n', conf)
+        self.check('---\n'
+                   'array: {    }\n', conf, problem=(2, 12))
+
+    def test_min_and_max_spaces_empty(self):
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 2\n'
+                '  min-spaces-inside-empty: 1\n')
+        self.check('---\n'
+                   'array: {}\n', conf, problem=(2, 9))
+        self.check('---\n'
+                   'array: { }\n', conf)
+        self.check('---\n'
+                   'array: {  }\n', conf)
+        self.check('---\n'
+                   'array: {   }\n', conf, problem=(2, 11))
+
+    def test_mixed_empty_nonempty(self):
+        conf = ('braces:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: 1\n'
+                '  max-spaces-inside-empty: 0\n'
+                '  min-spaces-inside-empty: 0\n')
+        self.check('---\n'
+                   'array: { a: 1, b }\n', conf)
+        self.check('---\n'
+                   'array: {a: 1, b}\n', conf,
+                   problem1=(2, 9), problem2=(2, 16))
+        self.check('---\n'
+                   'array: {}\n', conf)
+        self.check('---\n'
+                   'array: { }\n', conf,
+                   problem1=(2, 9))
+
+        conf = ('braces:\n'
+                '  max-spaces-inside: 0\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 1\n'
+                '  min-spaces-inside-empty: 1\n')
+        self.check('---\n'
+                   'array: { a: 1, b }\n', conf,
+                   problem1=(2, 9), problem2=(2, 17))
+        self.check('---\n'
+                   'array: {a: 1, b}\n', conf)
+        self.check('---\n'
+                   'array: {}\n', conf,
+                   problem1=(2, 9))
+        self.check('---\n'
+                   'array: { }\n', conf)
+
+        conf = ('braces:\n'
+                '  max-spaces-inside: 2\n'
+                '  min-spaces-inside: 1\n'
+                '  max-spaces-inside-empty: 1\n'
+                '  min-spaces-inside-empty: 1\n')
+        self.check('---\n'
+                   'array: { a: 1, b  }\n', conf)
+        self.check('---\n'
+                   'array: {a: 1, b   }\n', conf,
+                   problem1=(2, 9), problem2=(2, 18))
+        self.check('---\n'
+                   'array: {}\n', conf,
+                   problem1=(2, 9))
+        self.check('---\n'
+                   'array: { }\n', conf)
+        self.check('---\n'
+                   'array: {   }\n', conf,
+                   problem1=(2, 11))
+
+        conf = ('braces:\n'
+                '  max-spaces-inside: 1\n'
+                '  min-spaces-inside: 1\n'
+                '  max-spaces-inside-empty: 1\n'
+                '  min-spaces-inside-empty: 1\n')
+        self.check('---\n'
+                   'array: { a: 1, b }\n', conf)
+        self.check('---\n'
+                   'array: {a: 1, b}\n', conf,
+                   problem1=(2, 9), problem2=(2, 16))
+        self.check('---\n'
+                   'array: {}\n', conf,
+                   problem1=(2, 9))
+        self.check('---\n'
+                   'array: { }\n', conf)

tests/rules/test_brackets.py

@@ -32,11 +32,19 @@ class ColonTestCase(RuleTestCase):
                    'array7: [   a, b, c ]\n', conf)
 
     def test_min_spaces(self):
-        conf = 'brackets: {max-spaces-inside: -1, min-spaces-inside: 0}'
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: 0\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'array: []\n', conf)
 
-        conf = 'brackets: {max-spaces-inside: -1, min-spaces-inside: 1}'
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: 1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'array: []\n', conf, problem=(2, 9))
         self.check('---\n'
@@ -51,7 +59,11 @@ class ColonTestCase(RuleTestCase):
                    '  b\n'
                    ']\n', conf)
 
-        conf = 'brackets: {max-spaces-inside: -1, min-spaces-inside: 3}'
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: 3\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'array: [ a, b ]\n', conf,
                    problem1=(2, 10), problem2=(2, 15))
@@ -59,7 +71,11 @@ class ColonTestCase(RuleTestCase):
                    'array: [   a, b   ]\n', conf)
 
     def test_max_spaces(self):
-        conf = 'brackets: {max-spaces-inside: 0, min-spaces-inside: -1}'
+        conf = ('brackets:\n'
+                '  max-spaces-inside: 0\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'array: []\n', conf)
         self.check('---\n'
@@ -78,7 +94,11 @@ class ColonTestCase(RuleTestCase):
                    '  b\n'
                    ']\n', conf)
 
-        conf = 'brackets: {max-spaces-inside: 3, min-spaces-inside: -1}'
+        conf = ('brackets:\n'
+                '  max-spaces-inside: 3\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'array: [   a, b   ]\n', conf)
         self.check('---\n'
@@ -86,7 +106,11 @@ class ColonTestCase(RuleTestCase):
                    problem1=(2, 12), problem2=(2, 21))
 
     def test_min_and_max_spaces(self):
-        conf = 'brackets: {max-spaces-inside: 0, min-spaces-inside: 0}'
+        conf = ('brackets:\n'
+                '  max-spaces-inside: 0\n'
+                '  min-spaces-inside: 0\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'array: []\n', conf)
         self.check('---\n'
@@ -94,14 +118,169 @@ class ColonTestCase(RuleTestCase):
         self.check('---\n'
                    'array: [   a, b]\n', conf, problem=(2, 11))
 
-        conf = 'brackets: {max-spaces-inside: 1, min-spaces-inside: 1}'
+        conf = ('brackets:\n'
+                '  max-spaces-inside: 1\n'
+                '  min-spaces-inside: 1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'array: [a, b, c ]\n', conf, problem=(2, 9))
 
-        conf = 'brackets: {max-spaces-inside: 2, min-spaces-inside: 0}'
+        conf = ('brackets:\n'
+                '  max-spaces-inside: 2\n'
+                '  min-spaces-inside: 0\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: -1\n')
         self.check('---\n'
                    'array: [a, b, c ]\n', conf)
         self.check('---\n'
                    'array: [  a, b, c ]\n', conf)
         self.check('---\n'
                    'array: [   a, b, c ]\n', conf, problem=(2, 11))
+
+    def test_min_spaces_empty(self):
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 0\n'
+                '  min-spaces-inside-empty: 0\n')
+        self.check('---\n'
+                   'array: []\n', conf)
+
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: 1\n')
+        self.check('---\n'
+                   'array: []\n', conf, problem=(2, 9))
+        self.check('---\n'
+                   'array: [ ]\n', conf)
+
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: -1\n'
+                '  min-spaces-inside-empty: 3\n')
+        self.check('---\n'
+                   'array: []\n', conf, problem=(2, 9))
+        self.check('---\n'
+                   'array: [   ]\n', conf)
+
+    def test_max_spaces_empty(self):
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 0\n'
+                '  min-spaces-inside-empty: -1\n')
+        self.check('---\n'
+                   'array: []\n', conf)
+        self.check('---\n'
+                   'array: [ ]\n', conf, problem=(2, 9))
+
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 1\n'
+                '  min-spaces-inside-empty: -1\n')
+        self.check('---\n'
+                   'array: []\n', conf)
+        self.check('---\n'
+                   'array: [ ]\n', conf)
+        self.check('---\n'
+                   'array: [  ]\n', conf, problem=(2, 10))
+
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 3\n'
+                '  min-spaces-inside-empty: -1\n')
+        self.check('---\n'
+                   'array: []\n', conf)
+        self.check('---\n'
+                   'array: [   ]\n', conf)
+        self.check('---\n'
+                   'array: [    ]\n', conf, problem=(2, 12))
+
+    def test_min_and_max_spaces_empty(self):
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 2\n'
+                '  min-spaces-inside-empty: 1\n')
+        self.check('---\n'
+                   'array: []\n', conf, problem=(2, 9))
+        self.check('---\n'
+                   'array: [ ]\n', conf)
+        self.check('---\n'
+                   'array: [  ]\n', conf)
+        self.check('---\n'
+                   'array: [   ]\n', conf, problem=(2, 11))
+
+    def test_mixed_empty_nonempty(self):
+        conf = ('brackets:\n'
+                '  max-spaces-inside: -1\n'
+                '  min-spaces-inside: 1\n'
+                '  max-spaces-inside-empty: 0\n'
+                '  min-spaces-inside-empty: 0\n')
+        self.check('---\n'
+                   'array: [ a, b ]\n', conf)
+        self.check('---\n'
+                   'array: [a, b]\n', conf,
+                   problem1=(2, 9), problem2=(2, 13))
+        self.check('---\n'
+                   'array: []\n', conf)
+        self.check('---\n'
+                   'array: [ ]\n', conf,
+                   problem1=(2, 9))
+
+        conf = ('brackets:\n'
+                '  max-spaces-inside: 0\n'
+                '  min-spaces-inside: -1\n'
+                '  max-spaces-inside-empty: 1\n'
+                '  min-spaces-inside-empty: 1\n')
+        self.check('---\n'
+                   'array: [ a, b ]\n', conf,
+                   problem1=(2, 9), problem2=(2, 14))
+        self.check('---\n'
+                   'array: [a, b]\n', conf)
+        self.check('---\n'
+                   'array: []\n', conf,
+                   problem1=(2, 9))
+        self.check('---\n'
+                   'array: [ ]\n', conf)
+
+        conf = ('brackets:\n'
+                '  max-spaces-inside: 2\n'
+                '  min-spaces-inside: 1\n'
+                '  max-spaces-inside-empty: 1\n'
+                '  min-spaces-inside-empty: 1\n')
+        self.check('---\n'
+                   'array: [ a, b  ]\n', conf)
+        self.check('---\n'
+                   'array: [a, b   ]\n', conf,
+                   problem1=(2, 9), problem2=(2, 15))
+        self.check('---\n'
+                   'array: []\n', conf,
+                   problem1=(2, 9))
+        self.check('---\n'
+                   'array: [ ]\n', conf)
+        self.check('---\n'
+                   'array: [   ]\n', conf,
+                   problem1=(2, 11))
+
+        conf = ('brackets:\n'
+                '  max-spaces-inside: 1\n'
+                '  min-spaces-inside: 1\n'
+                '  max-spaces-inside-empty: 1\n'
+                '  min-spaces-inside-empty: 1\n')
+        self.check('---\n'
+                   'array: [ a, b ]\n', conf)
+        self.check('---\n'
+                   'array: [a, b]\n', conf,
+                   problem1=(2, 9), problem2=(2, 13))
+        self.check('---\n'
+                   'array: []\n', conf,
+                   problem1=(2, 9))
+        self.check('---\n'
+                   'array: [ ]\n', conf)

tests/rules/test_comments.py

@@ -35,11 +35,15 @@ class CommentsTestCase(RuleTestCase):
                    '  #comment 3 bis\n'
                    '  #  comment 3 ter\n'
                    '\n'
+                   '################################\n'
+                   '## comment 4\n'
+                   '##comment 5\n'
+                   '\n'
                    'string: "Une longue phrase." # this is French\n', conf)
 
     def test_starting_space(self):
         conf = ('comments:\n'
-                '  require-starting-space: yes\n'
+                '  require-starting-space: true\n'
                 '  min-spaces-from-content: -1\n'
                 'comments-indentation: disable\n')
         self.check('---\n'
@@ -52,7 +56,11 @@ class CommentsTestCase(RuleTestCase):
                    '# comment 2\n'
                    '# comment 3\n'
                    '  #  comment 3 bis\n'
-                   '  #  comment 3 ter\n', conf)
+                   '  #  comment 3 ter\n'
+                   '\n'
+                   '################################\n'
+                   '## comment 4\n'
+                   '##  comment 5\n', conf)
         self.check('---\n'
                    '#comment\n'
                    '\n'
@@ -63,13 +71,60 @@ class CommentsTestCase(RuleTestCase):
                    '# comment 2\n'
                    '#comment 3\n'
                    '  #comment 3 bis\n'
-                   '  #  comment 3 ter\n', conf,
+                   '  #  comment 3 ter\n'
+                   '\n'
+                   '################################\n'
+                   '## comment 4\n'
+                   '##comment 5\n', conf,
                    problem1=(2, 2), problem2=(6, 13),
-                   problem4=(9, 2), problem5=(10, 4))
+                   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: no\n'
+                '  require-starting-space: false\n'
                 '  min-spaces-from-content: 2\n')
         self.check('---\n'
                    '# comment\n'
@@ -91,7 +146,7 @@ class CommentsTestCase(RuleTestCase):
 
     def test_both(self):
         conf = ('comments:\n'
-                '  require-starting-space: yes\n'
+                '  require-starting-space: true\n'
                 '  min-spaces-from-content: 2\n'
                 'comments-indentation: disable\n')
         self.check('---\n'
@@ -106,17 +161,22 @@ class CommentsTestCase(RuleTestCase):
                    '  #comment 3 bis\n'
                    '  #  comment 3 ter\n'
                    '\n'
+                   '################################\n'
+                   '## comment 4\n'
+                   '##comment 5\n'
+                   '\n'
                    'string: "Une longue phrase." # this is French\n', conf,
                    problem1=(2, 2),
                    problem2=(4, 7),
                    problem3=(6, 11), problem4=(6, 12),
                    problem5=(9, 2),
                    problem6=(10, 4),
-                   problem7=(13, 30))
+                   problem7=(15, 3),
+                   problem8=(17, 30))
 
     def test_empty_comment(self):
         conf = ('comments:\n'
-                '  require-starting-space: yes\n'
+                '  require-starting-space: true\n'
                 '  min-spaces-from-content: 2\n')
         self.check('---\n'
                    '# This is paragraph 1.\n'
@@ -128,13 +188,21 @@ class CommentsTestCase(RuleTestCase):
 
     def test_first_line(self):
         conf = ('comments:\n'
-                '  require-starting-space: yes\n'
+                '  require-starting-space: true\n'
                 '  min-spaces-from-content: 2\n')
         self.check('# comment\n', conf)
 
+    def test_last_line(self):
+        conf = ('comments:\n'
+                '  require-starting-space: true\n'
+                '  min-spaces-from-content: 2\n'
+                'new-line-at-end-of-file: disable\n')
+        self.check('# comment with no newline char:\n'
+                   '#', conf)
+
     def test_multi_line_scalar(self):
         conf = ('comments:\n'
-                '  require-starting-space: yes\n'
+                '  require-starting-space: true\n'
                 '  min-spaces-from-content: 2\n'
                 'trailing-spaces: disable\n')
         self.check('---\n'

tests/rules/test_comments_indentation.py

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

tests/rules/test_common.py

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

tests/rules/test_document_end.py

@@ -31,7 +31,7 @@ class DocumentEndTestCase(RuleTestCase):
                    '  document: end\n', conf)
 
     def test_required(self):
-        conf = 'document-end: {present: yes}'
+        conf = 'document-end: {present: true}'
         self.check('', conf)
         self.check('\n', conf)
         self.check('---\n'
@@ -43,7 +43,7 @@ class DocumentEndTestCase(RuleTestCase):
                    '  document: end\n', conf, problem=(3, 1))
 
     def test_forbidden(self):
-        conf = 'document-end: {present: no}'
+        conf = 'document-end: {present: false}'
         self.check('---\n'
                    'with:\n'
                    '  document: end\n'
@@ -53,7 +53,7 @@ class DocumentEndTestCase(RuleTestCase):
                    '  document: end\n', conf)
 
     def test_multiple_documents(self):
-        conf = ('document-end: {present: yes}\n'
+        conf = ('document-end: {present: true}\n'
                 'document-start: disable\n')
         self.check('---\n'
                    'first: document\n'

tests/rules/test_document_start.py

@@ -28,7 +28,7 @@ class DocumentStartTestCase(RuleTestCase):
                    'key: val\n', conf)
 
     def test_required(self):
-        conf = ('document-start: {present: yes}\n'
+        conf = ('document-start: {present: true}\n'
                 'empty-lines: disable\n')
         self.check('', conf)
         self.check('\n', conf)
@@ -44,7 +44,7 @@ class DocumentStartTestCase(RuleTestCase):
                    'key: val\n', conf)
 
     def test_forbidden(self):
-        conf = ('document-start: {present: no}\n'
+        conf = ('document-start: {present: false}\n'
                 'empty-lines: disable\n')
         self.check('', conf)
         self.check('key: val\n', conf)
@@ -62,7 +62,7 @@ class DocumentStartTestCase(RuleTestCase):
                    'key: val\n', conf, problem=(2, 1))
 
     def test_multiple_documents(self):
-        conf = 'document-start: {present: yes}'
+        conf = 'document-start: {present: true}'
         self.check('---\n'
                    'first: document\n'
                    '...\n'
@@ -85,7 +85,7 @@ class DocumentStartTestCase(RuleTestCase):
                    'third: document\n', conf, problem=(4, 1, 'syntax'))
 
     def test_directives(self):
-        conf = 'document-start: {present: yes}'
+        conf = 'document-start: {present: true}'
         self.check('%YAML 1.2\n'
                    '---\n'
                    'doc: ument\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_empty_values.py

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 Greg Dubicki
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from tests.common import RuleTestCase
+
+
+class EmptyValuesTestCase(RuleTestCase):
+    rule_id = 'empty-values'
+
+    def test_disabled(self):
+        conf = ('empty-values: disable\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   'foo:\n', conf)
+        self.check('---\n'
+                   'foo:\n'
+                   ' bar:\n', conf)
+        self.check('---\n'
+                   '{a:}\n', conf)
+        self.check('---\n'
+                   'foo: {a:}\n', conf)
+        self.check('---\n'
+                   '- {a:}\n'
+                   '- {a:, b: 2}\n'
+                   '- {a: 1, b:}\n'
+                   '- {a: 1, b: , }\n', conf)
+        self.check('---\n'
+                   '{a: {b: , c: {d: 4, e:}}, f:}\n', conf)
+
+    def test_in_block_mappings_disabled(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n', conf)
+        self.check('---\n'
+                   'foo:\n'
+                   'bar: aaa\n', conf)
+
+    def test_in_block_mappings_single_line(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'implicitly-null:\n', conf, problem1=(2, 17))
+        self.check('---\n'
+                   'implicitly-null:with-colons:in-key:\n', conf,
+                   problem1=(2, 36))
+        self.check('---\n'
+                   'implicitly-null:with-colons:in-key2:\n', conf,
+                   problem1=(2, 37))
+
+    def test_in_block_mappings_all_lines(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   'bar:\n'
+                   'foobar:\n', conf, problem1=(2, 5),
+                   problem2=(3, 5), problem3=(4, 8))
+
+    def test_in_block_mappings_explicit_end_of_document(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   '...\n', conf, problem1=(2, 5))
+
+    def test_in_block_mappings_not_end_of_document(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   'bar:\n'
+                   ' aaa\n', conf, problem1=(2, 5))
+
+    def test_in_block_mappings_different_level(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   ' bar:\n'
+                   'aaa: bbb\n', conf, problem1=(3, 6))
+
+    def test_in_block_mappings_empty_flow_mapping(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   'foo: {a:}\n', conf)
+        self.check('---\n'
+                   '- {a:, b: 2}\n'
+                   '- {a: 1, b:}\n'
+                   '- {a: 1, b: , }\n', conf)
+
+    def test_in_block_mappings_empty_block_sequence(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   '  -\n', conf)
+
+    def test_in_block_mappings_not_empty_or_explicit_null(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'foo:\n'
+                   ' bar:\n'
+                   '  aaa\n', conf)
+        self.check('---\n'
+                   'explicitly-null: null\n', conf)
+        self.check('---\n'
+                   'explicitly-null:with-colons:in-key: null\n', conf)
+        self.check('---\n'
+                   'false-null: nulL\n', conf)
+        self.check('---\n'
+                   'empty-string: \'\'\n', conf)
+        self.check('---\n'
+                   'nullable-boolean: false\n', conf)
+        self.check('---\n'
+                   'nullable-int: 0\n', conf)
+        self.check('---\n'
+                   'First occurrence: &anchor Foo\n'
+                   'Second occurrence: *anchor\n', conf)
+
+    def test_in_block_mappings_various_explicit_null(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n')
+        self.check('---\n'
+                   'null-alias: ~\n', conf)
+        self.check('---\n'
+                   'null-key1: {?: val}\n', conf)
+        self.check('---\n'
+                   'null-key2: {? !!null "": val}\n', conf)
+
+    def test_in_block_mappings_comments(self):
+        conf = ('empty-values: {forbid-in-block-mappings: true,\n'
+                '               forbid-in-flow-mappings: false}\n'
+                'comments: disable\n')
+        self.check('---\n'
+                   'empty:  # comment\n'
+                   'foo:\n'
+                   '  bar: # comment\n', conf,
+                   problem1=(2, 7),
+                   problem2=(4, 7))
+
+    def test_in_flow_mappings_disabled(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: false}\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   '{a:}\n', conf)
+        self.check('---\n'
+                   'foo: {a:}\n', conf)
+        self.check('---\n'
+                   '- {a:}\n'
+                   '- {a:, b: 2}\n'
+                   '- {a: 1, b:}\n'
+                   '- {a: 1, b: , }\n', conf)
+        self.check('---\n'
+                   '{a: {b: , c: {d: 4, e:}}, f:}\n', conf)
+
+    def test_in_flow_mappings_single_line(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: true}\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   '{a:}\n', conf,
+                   problem=(2, 4))
+        self.check('---\n'
+                   'foo: {a:}\n', conf,
+                   problem=(2, 9))
+        self.check('---\n'
+                   '- {a:}\n'
+                   '- {a:, b: 2}\n'
+                   '- {a: 1, b:}\n'
+                   '- {a: 1, b: , }\n', conf,
+                   problem1=(2, 6),
+                   problem2=(3, 6),
+                   problem3=(4, 12),
+                   problem4=(5, 12))
+        self.check('---\n'
+                   '{a: {b: , c: {d: 4, e:}}, f:}\n', conf,
+                   problem1=(2, 8),
+                   problem2=(2, 23),
+                   problem3=(2, 29))
+
+    def test_in_flow_mappings_multi_line(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: true}\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   'foo: {\n'
+                   '  a:\n'
+                   '}\n', conf,
+                   problem=(3, 5))
+        self.check('---\n'
+                   '{\n'
+                   '  a: {\n'
+                   '    b: ,\n'
+                   '    c: {\n'
+                   '      d: 4,\n'
+                   '      e:\n'
+                   '    }\n'
+                   '  },\n'
+                   '  f:\n'
+                   '}\n', conf,
+                   problem1=(4, 7),
+                   problem2=(7, 9),
+                   problem3=(10, 5))
+
+    def test_in_flow_mappings_various_explicit_null(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: true}\n'
+                'braces: disable\n'
+                'commas: disable\n')
+        self.check('---\n'
+                   '{explicit-null: null}\n', conf)
+        self.check('---\n'
+                   '{null-alias: ~}\n', conf)
+        self.check('---\n'
+                   'null-key1: {?: val}\n', conf)
+        self.check('---\n'
+                   'null-key2: {? !!null "": val}\n', conf)
+
+    def test_in_flow_mappings_comments(self):
+        conf = ('empty-values: {forbid-in-block-mappings: false,\n'
+                '               forbid-in-flow-mappings: true}\n'
+                'braces: disable\n'
+                'commas: disable\n'
+                'comments: disable\n')
+        self.check('---\n'
+                   '{\n'
+                   '  a: {\n'
+                   '    b: ,  # comment\n'
+                   '    c: {\n'
+                   '      d: 4,  # comment\n'
+                   '      e:  # comment\n'
+                   '    }\n'
+                   '  },\n'
+                   '  f:  # comment\n'
+                   '}\n', conf,
+                   problem1=(4, 7),
+                   problem2=(7, 9),
+                   problem3=(10, 5))

tests/rules/test_key_duplicates.py

@@ -78,9 +78,18 @@ class KeyDuplicatesTestCase(RuleTestCase):
                    '    duplicates with\n'
                    '    many styles\n'
                    ': 1\n', conf)
+        self.check('---\n'
+                   'Merge Keys are OK:\n'
+                   'anchor_one: &anchor_one\n'
+                   '  one: one\n'
+                   'anchor_two: &anchor_two\n'
+                   '  two: two\n'
+                   'anchor_reference:\n'
+                   '  <<: *anchor_one\n'
+                   '  <<: *anchor_two\n', conf)
 
     def test_enabled(self):
-        conf = 'key-duplicates: {}'
+        conf = 'key-duplicates: enable'
         self.check('---\n'
                    'block mapping:\n'
                    '  key: a\n'
@@ -147,9 +156,18 @@ class KeyDuplicatesTestCase(RuleTestCase):
                    ': 1\n', conf,
                    problem1=(3, 1), problem2=(4, 1), problem3=(5, 3),
                    problem4=(7, 3))
+        self.check('---\n'
+                   'Merge Keys are OK:\n'
+                   'anchor_one: &anchor_one\n'
+                   '  one: one\n'
+                   'anchor_two: &anchor_two\n'
+                   '  two: two\n'
+                   'anchor_reference:\n'
+                   '  <<: *anchor_one\n'
+                   '  <<: *anchor_two\n', conf)
 
     def test_key_tokens_in_flow_sequences(self):
-        conf = 'key-duplicates: {}'
+        conf = 'key-duplicates: enable'
         self.check('---\n'
                    '[\n'
                    '  flow: sequence, with, key: value, mappings\n'

tests/rules/test_key_ordering.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 Johannes F. Knauf
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from tests.common import RuleTestCase
+
+
+class KeyOrderingTestCase(RuleTestCase):
+    rule_id = 'key-ordering'
+
+    def test_disabled(self):
+        conf = 'key-ordering: disable'
+        self.check('---\n'
+                   'block mapping:\n'
+                   '  secondkey: a\n'
+                   '  firstkey: b\n', conf)
+        self.check('---\n'
+                   'flow mapping:\n'
+                   '  {secondkey: a, firstkey: b}\n', conf)
+        self.check('---\n'
+                   'second: before_first\n'
+                   'at: root\n', conf)
+        self.check('---\n'
+                   'nested but OK:\n'
+                   '  second: {first: 1}\n'
+                   '  third:\n'
+                   '    second: 2\n', conf)
+
+    def test_enabled(self):
+        conf = 'key-ordering: enable'
+        self.check('---\n'
+                   'block mapping:\n'
+                   '  secondkey: a\n'
+                   '  firstkey: b\n', conf,
+                   problem=(4, 3))
+        self.check('---\n'
+                   'flow mapping:\n'
+                   '  {secondkey: a, firstkey: b}\n', conf,
+                   problem=(3, 18))
+        self.check('---\n'
+                   'second: before_first\n'
+                   'at: root\n', conf,
+                   problem=(3, 1))
+        self.check('---\n'
+                   'nested but OK:\n'
+                   '  second: {first: 1}\n'
+                   '  third:\n'
+                   '    second: 2\n', conf)
+
+    def test_word_length(self):
+        conf = 'key-ordering: enable'
+        self.check('---\n'
+                   'a: 1\n'
+                   'ab: 1\n'
+                   'abc: 1\n', conf)
+        self.check('---\n'
+                   'a: 1\n'
+                   'abc: 1\n'
+                   'ab: 1\n', conf,
+                   problem=(4, 1))
+
+    def test_key_duplicates(self):
+        conf = ('key-duplicates: disable\n'
+                'key-ordering: enable')
+        self.check('---\n'
+                   'key: 1\n'
+                   'key: 2\n', conf)
+
+    def test_case(self):
+        conf = 'key-ordering: enable'
+        self.check('---\n'
+                   'T-shirt: 1\n'
+                   'T-shirts: 2\n'
+                   't-shirt: 3\n'
+                   't-shirts: 4\n', conf)
+        self.check('---\n'
+                   'T-shirt: 1\n'
+                   't-shirt: 2\n'
+                   'T-shirts: 3\n'
+                   't-shirts: 4\n', conf,
+                   problem=(4, 1))
+
+    def test_accents(self):
+        conf = 'key-ordering: enable'
+        self.check('---\n'
+                   'hair: true\n'
+                   'hais: true\n'
+                   'haïr: true\n'
+                   'haïssable: true\n', conf)
+        self.check('---\n'
+                   'haïr: true\n'
+                   'hais: true\n', conf,
+                   problem=(3, 1))
+        self.check('---\n'
+                   'haïr: true\n'
+                   'hais: true\n', conf,
+                   problem=(3, 1))
+
+    def test_key_tokens_in_flow_sequences(self):
+        conf = 'key-ordering: enable'
+        self.check('---\n'
+                   '[\n'
+                   '  key: value, mappings, in, flow: sequence\n'
+                   ']\n', conf)

tests/rules/test_line_length.py

@@ -14,6 +14,9 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import sys
+import unittest
+
 from tests.common import RuleTestCase
 
 
@@ -32,6 +35,9 @@ class LineLengthTestCase(RuleTestCase):
         self.check('---\n' + 81 * 'a' + '\n', conf)
         self.check(1000 * 'b', conf)
         self.check('---\n' + 1000 * 'b' + '\n', conf)
+        self.check('content: |\n'
+                   '  {% this line is' + 99 * ' really' + ' long %}\n',
+                   conf)
 
     def test_default(self):
         conf = ('line-length: {max: 80}\n'
@@ -63,7 +69,7 @@ class LineLengthTestCase(RuleTestCase):
         self.check('---\n' + 81 * ' ' + '\n', conf, problem=(2, 81))
 
     def test_non_breakable_word(self):
-        conf = 'line-length: {max: 20, allow-non-breakable-words: yes}'
+        conf = 'line-length: {max: 20, allow-non-breakable-words: true}'
         self.check('---\n' + 30 * 'A' + '\n', conf)
         self.check('---\n'
                    'this:\n'
@@ -78,8 +84,17 @@ class LineLengthTestCase(RuleTestCase):
                    '        # http://localhost/very/long/url\n'
                    '        comment\n'
                    '...\n', conf)
+        self.check('---\n'
+                   'this:\n'
+                   'is:\n'
+                   'another:\n'
+                   '  - https://localhost/very/very/long/url\n'
+                   '...\n', conf)
+        self.check('---\n'
+                   'long_line: http://localhost/very/very/long/url\n', conf,
+                   problem=(2, 21))
 
-        conf = 'line-length: {max: 20, allow-non-breakable-words: no}'
+        conf = 'line-length: {max: 20, allow-non-breakable-words: false}'
         self.check('---\n' + 30 * 'A' + '\n', conf, problem=(2, 21))
         self.check('---\n'
                    'this:\n'
@@ -94,3 +109,74 @@ class LineLengthTestCase(RuleTestCase):
                    '        # http://localhost/very/long/url\n'
                    '        comment\n'
                    '...\n', conf, problem=(5, 21))
+        self.check('---\n'
+                   'this:\n'
+                   'is:\n'
+                   'another:\n'
+                   '  - https://localhost/very/very/long/url\n'
+                   '...\n', conf, problem=(5, 21))
+        self.check('---\n'
+                   'long_line: http://localhost/very/very/long/url\n'
+                   '...\n', conf, problem=(2, 21))
+
+        conf = ('line-length: {max: 20, allow-non-breakable-words: true}\n'
+                'trailing-spaces: disable')
+        self.check('---\n'
+                   'loooooooooong+word+and+some+space+at+the+end       \n',
+                   conf, problem=(2, 21))
+
+    def test_non_breakable_inline_mappings(self):
+        conf = 'line-length: {max: 20, ' \
+               'allow-non-breakable-inline-mappings: true}'
+        self.check('---\n'
+                   'long_line: http://localhost/very/very/long/url\n'
+                   'long line: http://localhost/very/very/long/url\n', conf)
+        self.check('---\n'
+                   '- long line: http://localhost/very/very/long/url\n', conf)
+
+        self.check('---\n'
+                   'long_line: http://localhost/short/url + word\n'
+                   'long line: http://localhost/short/url + word\n',
+                   conf, problem1=(2, 21), problem2=(3, 21))
+
+        conf = ('line-length: {max: 20,'
+                '              allow-non-breakable-inline-mappings: true}\n'
+                'trailing-spaces: disable')
+        self.check('---\n'
+                   'long_line: and+some+space+at+the+end       \n',
+                   conf, problem=(2, 21))
+        self.check('---\n'
+                   'long line: and+some+space+at+the+end       \n',
+                   conf, problem=(2, 21))
+        self.check('---\n'
+                   '- long line: and+some+space+at+the+end       \n',
+                   conf, problem=(2, 21))
+
+        # See https://github.com/adrienverge/yamllint/issues/21
+        conf = 'line-length: {allow-non-breakable-inline-mappings: true}'
+        self.check('---\n'
+                   '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_line_at_end_of_file.py

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

tests/rules/test_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

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2016 Adrien Vergé
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from tests.common import RuleTestCase
+
+
+class OctalValuesTestCase(RuleTestCase):
+    rule_id = 'octal-values'
+
+    def test_disabled(self):
+        conf = ('octal-values: disable\n'
+                'new-line-at-end-of-file: disable\n'
+                'document-start: disable\n')
+        self.check('user-city: 010', conf)
+        self.check('user-city: 0o10', conf)
+
+    def test_implicit_octal_values(self):
+        conf = ('octal-values:\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))
+        self.check('user-city: abc', conf)
+        self.check('user-city: 010,0571', conf)
+        self.check("user-city: '010'", conf)
+        self.check('user-city: "010"', conf)
+        self.check('user-city:\n'
+                   '  - 010', conf, problem=(2, 8))
+        self.check('user-city: [010]', conf, problem=(1, 16))
+        self.check('user-city: {beijing: 010}', conf, problem=(1, 25))
+        self.check('explicit-octal: 0o10', conf)
+        self.check('not-number: 0abc', conf)
+        self.check('zero: 0', conf)
+        self.check('hex-value: 0x10', conf)
+        self.check('number-values:\n'
+                   '  - 0.10\n'
+                   '  - .01\n'
+                   '  - 0e3\n', conf)
+
+    def test_explicit_octal_values(self):
+        conf = ('octal-values:\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))
+        self.check('user-city: abc', conf)
+        self.check('user-city: 0o10,0571', conf)
+        self.check("user-city: '0o10'", conf)
+        self.check('user-city:\n'
+                   '  - 0o10', conf, problem=(2, 9))
+        self.check('user-city: [0o10]', conf, problem=(1, 17))
+        self.check('user-city: {beijing: 0o10}', conf, problem=(1, 26))
+        self.check('implicit-octal: 010', conf)
+        self.check('not-number: 0oabc', conf)
+        self.check('zero: 0', conf)
+        self.check('hex-value: 0x10', conf)
+        self.check('number-values:\n'
+                   '  - 0.10\n'
+                   '  - .01\n'
+                   '  - 0e3\n', conf)
+        self.check('user-city: "010"', conf)

tests/rules/test_quoted_strings.py

@@ -0,0 +1,359 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018 ClearScore
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from tests.common import RuleTestCase
+
+
+class QuotedTestCase(RuleTestCase):
+    rule_id = 'quoted-strings'
+
+    def test_disabled(self):
+        conf = 'quoted-strings: disable'
+
+        self.check('---\n'
+                   'foo: bar\n', conf)
+        self.check('---\n'
+                   'foo: "bar"\n', conf)
+        self.check('---\n'
+                   'foo: \'bar\'\n', conf)
+        self.check('---\n'
+                   'bar: 123\n', conf)
+        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: "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'
+                   'block-seq:\n'
+                   '  - foo\n'                               # fails
+                   '  - "foo"\n'
+                   'flow-seq: [foo, "foo"]\n'                # fails
+                   'flow-map: {a: foo, b: "foo"}\n',         # fails
+                   conf, problem1=(4, 10), problem2=(17, 5),
+                   problem3=(19, 12), problem4=(20, 15))
+        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_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: "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'
+                   'block-seq:\n'
+                   '  - foo\n'                               # fails
+                   '  - "foo"\n'                             # fails
+                   'flow-seq: [foo, "foo"]\n'                # fails
+                   'flow-map: {a: foo, b: "foo"}\n',         # fails
+                   conf, problem1=(4, 10), problem2=(5, 10), problem3=(6, 10),
+                   problem4=(7, 10), problem5=(17, 5), problem6=(18, 5),
+                   problem7=(19, 12), problem8=(19, 17), problem9=(20, 15),
+                   problem10=(20, 23))
+        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), problem2=(12, 3))
+
+    def test_quote_type_double(self):
+        conf = 'quoted-strings: {quote-type: double}\n'
+
+        self.check('---\n'
+                   'boolean1: true\n'
+                   'number1: 123\n'
+                   'string1: foo\n'                          # fails
+                   'string2: "foo"\n'
+                   'string3: "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'
+                   'block-seq:\n'
+                   '  - foo\n'                               # fails
+                   '  - "foo"\n'
+                   'flow-seq: [foo, "foo"]\n'                # fails
+                   'flow-map: {a: foo, b: "foo"}\n',         # fails
+                   conf, problem1=(4, 10), problem2=(8, 10), problem3=(17, 5),
+                   problem4=(19, 12), problem5=(20, 15))
+        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_any_quotes_not_required(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'
+                   'block-seq:\n'
+                   '  - foo\n'                               # fails
+                   '  - "foo"\n'
+                   'flow-seq: [foo, "foo"]\n'                # fails
+                   'flow-map: {a: foo, b: "foo"}\n',         # fails
+                   conf)
+        self.check('---\n'
+                   'multiline string 1: |\n'
+                   '  line 1\n'
+                   '  line 2\n'
+                   'multiline string 2: >\n'
+                   '  word 1\n'
+                   '  word 2\n'
+                   'multiline string 3:\n'
+                   '  word 1\n'
+                   '  word 2\n'
+                   'multiline string 4:\n'
+                   '  "word 1\\\n'
+                   '   word 2"\n',
+                   conf)
+
+    def test_single_quotes_not_required(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'
+                   'block-seq:\n'
+                   '  - foo\n'                               # fails
+                   '  - "foo"\n'
+                   'flow-seq: [foo, "foo"]\n'                # fails
+                   'flow-map: {a: foo, b: "foo"}\n',         # fails
+                   conf, problem1=(5, 10), problem2=(6, 10), problem3=(7, 10),
+                   problem4=(18, 5), problem5=(19, 17), problem6=(20, 23))
+        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_only_when_needed(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'
+                   'block-seq:\n'
+                   '  - foo\n'
+                   '  - "foo"\n'                             # fails
+                   'flow-seq: [foo, "foo"]\n'                # fails
+                   'flow-map: {a: foo, b: "foo"}\n',         # fails
+                   conf, problem1=(5, 10), problem2=(8, 10), problem3=(18, 5),
+                   problem4=(19, 17), problem5=(20, 23))
+        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_only_when_needed_single_quotes(self):
+        conf = ('quoted-strings: {quote-type: single,\n'
+                '                 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'
+                   'block-seq:\n'
+                   '  - foo\n'
+                   '  - "foo"\n'                             # fails
+                   'flow-seq: [foo, "foo"]\n'                # fails
+                   'flow-map: {a: foo, b: "foo"}\n',         # fails
+                   conf, problem1=(5, 10), problem2=(6, 10), problem3=(7, 10),
+                   problem4=(8, 10), problem5=(18, 5), problem6=(19, 17),
+                   problem7=(20, 23))
+        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_only_when_needed_corner_cases(self):
+        conf = 'quoted-strings: {required: only-when-needed}\n'
+
+        self.check('---\n'
+                   '- ""\n'
+                   '- "- item"\n'
+                   '- "key: value"\n'
+                   '- "%H:%M:%S"\n'
+                   '- "%wheel ALL=(ALL) NOPASSWD: ALL"\n'
+                   '- \'"quoted"\'\n'
+                   '- "\'foo\' == \'bar\'"\n'
+                   '- "\'Mac\' in ansible_facts.product_name"\n',
+                   conf)
+        self.check('---\n'
+                   'k1: ""\n'
+                   'k2: "- item"\n'
+                   'k3: "key: value"\n'
+                   'k4: "%H:%M:%S"\n'
+                   'k5: "%wheel ALL=(ALL) NOPASSWD: ALL"\n'
+                   'k6: \'"quoted"\'\n'
+                   'k7: "\'foo\' == \'bar\'"\n'
+                   'k8: "\'Mac\' in ansible_facts.product_name"\n',
+                   conf)
+
+        self.check('---\n'
+                   '- ---\n'
+                   '- "---"\n'                     # fails
+                   '- ----------\n'
+                   '- "----------"\n'              # fails
+                   '- :wq\n'
+                   '- ":wq"\n',                    # fails
+                   conf, problem1=(3, 3), problem2=(5, 3), problem3=(7, 3))
+        self.check('---\n'
+                   'k1: ---\n'
+                   'k2: "---"\n'                   # fails
+                   'k3: ----------\n'
+                   'k4: "----------"\n'            # fails
+                   'k5: :wq\n'
+                   'k6: ":wq"\n',                  # fails
+                   conf, problem1=(3, 5), problem2=(5, 5), problem3=(7, 5))

tests/rules/test_trailing_spaces.py

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

tests/rules/test_truthy.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2016 Peter Ericson
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from tests.common import RuleTestCase
+
+
+class TruthyTestCase(RuleTestCase):
+    rule_id = 'truthy'
+
+    def test_disabled(self):
+        conf = 'truthy: disable'
+        self.check('---\n'
+                   '1: True\n', conf)
+        self.check('---\n'
+                   'True: 1\n', conf)
+
+    def test_enabled(self):
+        conf = 'truthy: enable\n'
+        self.check('---\n'
+                   '1: True\n'
+                   'True: 1\n',
+                   conf, problem1=(2, 4), problem2=(3, 1))
+        self.check('---\n'
+                   '1: "True"\n'
+                   '"True": 1\n', conf)
+        self.check('---\n'
+                   '[\n'
+                   '  true, false,\n'
+                   '  "false", "FALSE",\n'
+                   '  "true", "True",\n'
+                   '  True, FALSE,\n'
+                   '  on, OFF,\n'
+                   '  NO, Yes\n'
+                   ']\n', conf,
+                   problem1=(6, 3), problem2=(6, 9),
+                   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'
+                   'string1: !!str True\n'
+                   'string2: !!str yes\n'
+                   'string3: !!str off\n'
+                   'encoded: !!binary |\n'
+                   '           True\n'
+                   '           OFF\n'
+                   '           pad==\n'  # this decodes as 'N\xbb\x9e8Qii'
+                   'boolean1: !!bool true\n'
+                   'boolean2: !!bool "false"\n'
+                   'boolean3: !!bool FALSE\n'
+                   'boolean4: !!bool True\n'
+                   'boolean5: !!bool off\n'
+                   'boolean6: !!bool NO\n',
+                   conf)
+
+    def test_check_keys_disabled(self):
+        conf = ('truthy:\n'
+                '  allowed-values: []\n'
+                '  check-keys: false\n'
+                'key-duplicates: disable\n')
+        self.check('---\n'
+                   'YES: 0\n'
+                   'Yes: 0\n'
+                   'yes: 0\n'
+                   'No: 0\n'
+                   'No: 0\n'
+                   'no: 0\n'
+                   'TRUE: 0\n'
+                   'True: 0\n'
+                   'true: 0\n'
+                   'FALSE: 0\n'
+                   'False: 0\n'
+                   'false: 0\n'
+                   'ON: 0\n'
+                   'On: 0\n'
+                   'on: 0\n'
+                   'OFF: 0\n'
+                   'Off: 0\n'
+                   'off: 0\n'
+                   'YES:\n'
+                   '  Yes:\n'
+                   '    yes:\n'
+                   '      on: 0\n',
+                   conf)

tests/test_cli.py

@@ -0,0 +1,519 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2016 Adrien Vergé
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from io import StringIO
+import fcntl
+import locale
+import os
+import pty
+import shutil
+import sys
+import 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
+
+
+class CommandLineTestCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super(CommandLineTestCase, cls).setUpClass()
+
+        cls.wd = build_temp_workspace({
+            # .yaml file at root
+            'a.yaml': '---\n'
+                      '- 1   \n'
+                      '- 2',
+            # file with only one warning
+            'warn.yaml': 'key: value\n',
+            # .yml file at root
+            'empty.yml': '',
+            # file in dir
+            'sub/ok.yaml': '---\n'
+                           'key: value\n',
+            # file in very nested dir
+            's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml': '---\n'
+                                                       'key: value\n'
+                                                       'key: other value\n',
+            # empty dir
+            'empty-dir': [],
+            # non-YAML file
+            'no-yaml.json': '---\n'
+                            'key: value\n',
+            # non-ASCII chars
+            'non-ascii/éçäγλνπ¥/utf-8': (
+                u'---\n'
+                u'- hétérogénéité\n'
+                u'# 19.99 €\n'
+                u'- お早う御座います。\n'
+                u'# الأَبْجَدِيَّة العَرَبِيَّة\n').encode('utf-8'),
+            # dos line endings yaml
+            'dos.yml': '---\r\n'
+                       'dos: true',
+        })
+
+    @classmethod
+    def tearDownClass(cls):
+        super(CommandLineTestCase, cls).tearDownClass()
+
+        shutil.rmtree(cls.wd)
+
+    def test_find_files_recursively(self):
+        conf = config.YamlLintConfig('extends: default')
+        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, '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')],
+        )
+
+        items = [os.path.join(self.wd, 'sub/ok.yaml'),
+                 os.path.join(self.wd, 'empty-dir')]
+        self.assertEqual(
+            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, 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')],
+        )
+
+        items = [os.path.join(self.wd, 'sub'),
+                 os.path.join(self.wd, '/etc/another/file')]
+        self.assertEqual(
+            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):
+        with RunContext(self) as ctx:
+            cli.run(())
+        self.assertNotEqual(ctx.returncode, 0)
+        self.assertEqual(ctx.stdout, '')
+        self.assertRegexpMatches(ctx.stderr, r'^usage')
+
+        with RunContext(self) as ctx:
+            cli.run(('--unknown-arg', ))
+        self.assertNotEqual(ctx.returncode, 0)
+        self.assertEqual(ctx.stdout, '')
+        self.assertRegexpMatches(ctx.stderr, r'^usage')
+
+        with RunContext(self) as ctx:
+            cli.run(('-c', './conf.yaml', '-d', 'relaxed', 'file'))
+        self.assertNotEqual(ctx.returncode, 0)
+        self.assertEqual(ctx.stdout, '')
+        self.assertRegexpMatches(
+            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):
+        with RunContext(self) as ctx:
+            cli.run(('-d', 'rules: {a: b}', 'file'))
+        self.assertEqual(ctx.returncode, -1)
+        self.assertEqual(ctx.stdout, '')
+        self.assertRegexpMatches(ctx.stderr, r'^invalid config: no such rule')
+
+    def test_run_with_empty_config(self):
+        with RunContext(self) as ctx:
+            cli.run(('-d', '', 'file'))
+        self.assertEqual(ctx.returncode, -1)
+        self.assertEqual(ctx.stdout, '')
+        self.assertRegexpMatches(ctx.stderr, 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 RunContext(self) as ctx:
+            cli.run(('-c', f.name, os.path.join(self.wd, 'a.yaml')))
+        self.assertEqual(ctx.returncode, 0)
+
+        with open(os.path.join(self.wd, 'config'), 'w') as f:
+            f.write('rules: {trailing-spaces: enable}')
+
+        with RunContext(self) as ctx:
+            cli.run(('-c', f.name, os.path.join(self.wd, 'a.yaml')))
+        self.assertEqual(ctx.returncode, 1)
+
+    def test_run_with_user_global_config_file(self):
+        home = os.path.join(self.wd, 'fake-home')
+        dir = os.path.join(home, '.config', 'yamllint')
+        os.makedirs(dir)
+        config = os.path.join(dir, 'config')
+
+        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 RunContext(self) as ctx:
+            cli.run((os.path.join(self.wd, 'a.yaml'), ))
+        self.assertEqual(ctx.returncode, 0)
+
+        with open(config, 'w') as f:
+            f.write('rules: {trailing-spaces: enable}')
+
+        with RunContext(self) as ctx:
+            cli.run((os.path.join(self.wd, 'a.yaml'), ))
+        self.assertEqual(ctx.returncode, 1)
+
+    def test_run_version(self):
+        with RunContext(self) as ctx:
+            cli.run(('--version', ))
+        self.assertEqual(ctx.returncode, 0)
+        self.assertRegexpMatches(ctx.stdout + ctx.stderr, r'yamllint \d+\.\d+')
+
+    def test_run_non_existing_file(self):
+        path = os.path.join(self.wd, 'i-do-not-exist.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run(('-f', 'parsable', path))
+        self.assertEqual(ctx.returncode, -1)
+        self.assertEqual(ctx.stdout, '')
+        self.assertRegexpMatches(ctx.stderr, r'No such file or directory')
+
+    def test_run_one_problem_file(self):
+        path = os.path.join(self.wd, 'a.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run(('-f', 'parsable', path))
+        self.assertEqual(ctx.returncode, 1)
+        self.assertEqual(ctx.stdout, (
+            '%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' % (path, path)))
+        self.assertEqual(ctx.stderr, '')
+
+    def test_run_one_warning(self):
+        path = os.path.join(self.wd, 'warn.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run(('-f', 'parsable', path))
+        self.assertEqual(ctx.returncode, 0)
+
+    def test_run_warning_in_strict_mode(self):
+        path = os.path.join(self.wd, 'warn.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run(('-f', 'parsable', '--strict', path))
+        self.assertEqual(ctx.returncode, 2)
+
+    def test_run_one_ok_file(self):
+        path = os.path.join(self.wd, 'sub', 'ok.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run(('-f', 'parsable', path))
+        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
+
+    def test_run_empty_file(self):
+        path = os.path.join(self.wd, 'empty.yml')
+
+        with RunContext(self) as ctx:
+            cli.run(('-f', 'parsable', path))
+        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
+
+    def test_run_non_ascii_file(self):
+        path = os.path.join(self.wd, 'non-ascii', 'éçäγλνπ¥', 'utf-8')
+
+        # Make sure the default localization conditions on this "system"
+        # support UTF-8 encoding.
+        loc = locale.getlocale()
+        try:
+            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)
+
+        with RunContext(self) as ctx:
+            cli.run(('-f', 'parsable', path))
+        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
+
+    def test_run_multiple_files(self):
+        items = [os.path.join(self.wd, 'empty.yml'),
+                 os.path.join(self.wd, 's')]
+        path = items[1] + '/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'
+
+        with RunContext(self) as ctx:
+            cli.run(['-f', 'parsable'] + items)
+        self.assertEqual((ctx.returncode, ctx.stderr), (1, ''))
+        self.assertEqual(ctx.stdout, (
+            '%s:3:1: [error] duplication of key "key" in mapping '
+            '(key-duplicates)\n') % path)
+
+    def test_run_piped_output_nocolor(self):
+        path = os.path.join(self.wd, 'a.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run((path, ))
+        self.assertEqual((ctx.returncode, ctx.stderr), (1, ''))
+        self.assertEqual(ctx.stdout, (
+            '%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))
+
+    def test_run_default_format_output_in_tty(self):
+        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((path, ))
+        sys.stdout.flush()
+
+        self.assertEqual(ctx.exception.code, 1)
+
+        # Read output from TTY
+        output = os.fdopen(master, 'r')
+        flag = fcntl.fcntl(master, fcntl.F_GETFD)
+        fcntl.fcntl(master, fcntl.F_SETFL, flag | os.O_NONBLOCK)
+
+        out = output.read().replace('\r\n', '\n')
+
+        sys.stdout.close()
+        sys.stderr.close()
+        output.close()
+
+        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' % path))
+
+    def test_run_default_format_output_without_tty(self):
+        path = os.path.join(self.wd, 'a.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run((path, ))
+        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, ''))
+
+    def test_run_auto_output_without_tty_output(self):
+        path = os.path.join(self.wd, 'a.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run((path, '--format', '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, ''))
+
+    def test_run_format_colored(self):
+        path = os.path.join(self.wd, 'a.yaml')
+
+        with RunContext(self) as ctx:
+            cli.run((path, '--format', 'colored'))
+        expected_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' % path)
+        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

@@ -14,8 +14,19 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from io import StringIO
+import os
+import shutil
+import sys
+import tempfile
 import unittest
 
+from tests.common import build_temp_workspace
+
+from yamllint import cli
 from yamllint import config
 
 
@@ -30,23 +41,30 @@ class SimpleConfigTestCase(unittest.TestCase):
         self.assertEqual(new.rules['colons']['max-spaces-before'], 0)
         self.assertEqual(new.rules['colons']['max-spaces-after'], 1)
 
-        self.assertEqual(len(new.enabled_rules()), 1)
+        self.assertEqual(len(new.enabled_rules(None)), 1)
+
+    def test_invalid_conf(self):
+        with self.assertRaises(config.YamlLintConfigError):
+            config.YamlLintConfig('not: valid: yaml')
 
     def test_unknown_rule(self):
         with self.assertRaisesRegexp(
                 config.YamlLintConfigError,
                 'invalid config: no such rule: "this-one-does-not-exist"'):
             config.YamlLintConfig('rules:\n'
-                                  '  this-one-does-not-exist: {}\n')
+                                  '  this-one-does-not-exist: enable\n')
 
     def test_missing_option(self):
-        with self.assertRaisesRegexp(
+        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(
@@ -58,9 +76,126 @@ class SimpleConfigTestCase(unittest.TestCase):
                                   '    max-spaces-after: 1\n'
                                   '    abcdef: yes\n')
 
+    def test_yes_no_for_booleans(self):
+        c = config.YamlLintConfig('rules:\n'
+                                  '  indentation:\n'
+                                  '    spaces: 2\n'
+                                  '    indent-sequences: true\n'
+                                  '    check-multi-line-strings: false\n')
+        self.assertTrue(c.rules['indentation']['indent-sequences'])
+        self.assertEqual(c.rules['indentation']['check-multi-line-strings'],
+                         False)
+
+        c = config.YamlLintConfig('rules:\n'
+                                  '  indentation:\n'
+                                  '    spaces: 2\n'
+                                  '    indent-sequences: yes\n'
+                                  '    check-multi-line-strings: false\n')
+        self.assertTrue(c.rules['indentation']['indent-sequences'])
+        self.assertEqual(c.rules['indentation']['check-multi-line-strings'],
+                         False)
+
+        c = config.YamlLintConfig('rules:\n'
+                                  '  indentation:\n'
+                                  '    spaces: 2\n'
+                                  '    indent-sequences: whatever\n'
+                                  '    check-multi-line-strings: false\n')
+        self.assertEqual(c.rules['indentation']['indent-sequences'],
+                         'whatever')
+        self.assertEqual(c.rules['indentation']['check-multi-line-strings'],
+                         False)
+
+        with self.assertRaisesRegexp(
+                config.YamlLintConfigError,
+                'invalid config: option "indent-sequences" of "indentation" '
+                'should be in '):
+            c = config.YamlLintConfig('rules:\n'
+                                      '  indentation:\n'
+                                      '    spaces: 2\n'
+                                      '    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.assertFalse(config.validate_rule_conf(Rule, False))
+        self.assertEqual(config.validate_rule_conf(Rule, {}),
+                         {'level': 'error'})
+
+        config.validate_rule_conf(Rule, {'level': 'error'})
+        config.validate_rule_conf(Rule, {'level': 'warning'})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'level': 'warn'})
+
+        Rule.CONF = {'length': int}
+        Rule.DEFAULT = {'length': 80}
+        config.validate_rule_conf(Rule, {'length': 8})
+        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})
+        config.validate_rule_conf(Rule, {'a': True})
+        config.validate_rule_conf(Rule, {'b': 0})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'a': 1, 'b': 0})
+
+        Rule.CONF = {'choice': (True, 88, 'str')}
+        Rule.DEFAULT = {'choice': 88}
+        config.validate_rule_conf(Rule, {'choice': True})
+        config.validate_rule_conf(Rule, {'choice': 88})
+        config.validate_rule_conf(Rule, {'choice': 'str'})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'choice': False})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'choice': 99})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'choice': 'abc'})
+
+        Rule.CONF = {'choice': (int, 'hardcoded')}
+        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'
@@ -75,62 +210,132 @@ class ExtendedConfigTestCase(unittest.TestCase):
         self.assertEqual(new.rules['colons']['max-spaces-after'], 1)
         self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
 
-        self.assertEqual(len(new.enabled_rules()), 2)
+        self.assertEqual(len(new.enabled_rules(None)), 2)
+
+    def test_extend_on_file(self):
+        with tempfile.NamedTemporaryFile('w') as f:
+            f.write('rules:\n'
+                    '  colons:\n'
+                    '    max-spaces-before: 0\n'
+                    '    max-spaces-after: 1\n')
+            f.flush()
+            c = config.YamlLintConfig('extends: ' + f.name + '\n'
+                                      'rules:\n'
+                                      '  hyphens:\n'
+                                      '    max-spaces-after: 2\n')
+
+        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
+        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
+        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
+
+        self.assertEqual(len(c.enabled_rules(None)), 2)
 
     def test_extend_remove_rule(self):
-        old = config.YamlLintConfig('rules:\n'
+        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()), 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()), 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()), 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):
@@ -162,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')
@@ -175,3 +383,98 @@ class ExtendedLibraryConfigTestCase(unittest.TestCase):
         self.assertEqual(sorted(new.rules.keys()), sorted(old.rules.keys()))
         for rule in new.rules:
             self.assertEqual(new.rules[rule], old.rules[rule])
+        self.assertEqual(new.rules['empty-lines']['max'], 2)
+        self.assertEqual(new.rules['empty-lines']['max-start'], 42)
+        self.assertEqual(new.rules['empty-lines']['max-end'], 0)
+
+
+class IgnorePathConfigTestCase(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super(IgnorePathConfigTestCase, cls).setUpClass()
+
+        bad_yaml = ('---\n'
+                    '- key: val1\n'
+                    '  key: val2\n'
+                    '- trailing space \n'
+                    '-    lonely hyphen\n')
+
+        cls.wd = build_temp_workspace({
+            'bin/file.lint-me-anyway.yaml': bad_yaml,
+            'bin/file.yaml': bad_yaml,
+            'file-at-root.yaml': bad_yaml,
+            'file.dont-lint-me.yaml': bad_yaml,
+            'ign-dup/file.yaml': bad_yaml,
+            'ign-dup/sub/dir/file.yaml': bad_yaml,
+            'ign-trail/file.yaml': bad_yaml,
+            'include/ign-dup/sub/dir/file.yaml': bad_yaml,
+            's/s/ign-trail/file.yaml': bad_yaml,
+            's/s/ign-trail/s/s/file.yaml': bad_yaml,
+            's/s/ign-trail/s/s/file2.lint-me-anyway.yaml': bad_yaml,
+
+            '.yamllint': 'ignore: |\n'
+                         '  *.dont-lint-me.yaml\n'
+                         '  /bin/\n'
+                         '  !/bin/*.lint-me-anyway.yaml\n'
+                         '\n'
+                         'extends: default\n'
+                         '\n'
+                         'rules:\n'
+                         '  key-duplicates:\n'
+                         '    ignore: |\n'
+                         '      /ign-dup\n'
+                         '  trailing-spaces:\n'
+                         '    ignore: |\n'
+                         '      ign-trail\n'
+                         '      !*.lint-me-anyway.yaml\n',
+        })
+
+        cls.backup_wd = os.getcwd()
+        os.chdir(cls.wd)
+
+    @classmethod
+    def tearDownClass(cls):
+        super(IgnorePathConfigTestCase, cls).tearDownClass()
+
+        os.chdir(cls.backup_wd)
+
+        shutil.rmtree(cls.wd)
+
+    def test_run_with_ignored_path(self):
+        sys.stdout = StringIO()
+        with self.assertRaises(SystemExit):
+            cli.run(('-f', 'parsable', '.'))
+
+        out = sys.stdout.getvalue()
+        out = '\n'.join(sorted(out.splitlines()))
+
+        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,
+            './file-at-root.yaml:3:3: ' + keydup,
+            './file-at-root.yaml:4:17: ' + trailing,
+            './file-at-root.yaml:5:5: ' + hyphen,
+            './ign-dup/file.yaml:4:17: ' + trailing,
+            './ign-dup/file.yaml:5:5: ' + hyphen,
+            './ign-dup/sub/dir/file.yaml:4:17: ' + trailing,
+            './ign-dup/sub/dir/file.yaml:5:5: ' + hyphen,
+            './ign-trail/file.yaml:3:3: ' + keydup,
+            './ign-trail/file.yaml:5:5: ' + hyphen,
+            './include/ign-dup/sub/dir/file.yaml:3:3: ' + keydup,
+            './include/ign-dup/sub/dir/file.yaml:4:17: ' + trailing,
+            './include/ign-dup/sub/dir/file.yaml:5:5: ' + hyphen,
+            './s/s/ign-trail/file.yaml:3:3: ' + keydup,
+            './s/s/ign-trail/file.yaml:5:5: ' + hyphen,
+            './s/s/ign-trail/s/s/file.yaml:3:3: ' + keydup,
+            './s/s/ign-trail/s/s/file.yaml:5:5: ' + hyphen,
+            './s/s/ign-trail/s/s/file2.lint-me-anyway.yaml:3:3: ' + keydup,
+            './s/s/ign-trail/s/s/file2.lint-me-anyway.yaml:4:17: ' + trailing,
+            './s/s/ign-trail/s/s/file2.lint-me-anyway.yaml:5:5: ' + hyphen,
+        )))

tests/test_linter.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2016 Adrien Vergé
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import io
+import unittest
+
+from yamllint.config import YamlLintConfig
+from yamllint import linter
+
+
+class LinterTestCase(unittest.TestCase):
+    def fake_config(self):
+        return YamlLintConfig('extends: default')
+
+    def test_run_on_string(self):
+        linter.run('test: document', self.fake_config())
+
+    def test_run_on_bytes(self):
+        linter.run(b'test: document', self.fake_config())
+
+    def test_run_on_unicode(self):
+        linter.run(u'test: document', self.fake_config())
+
+    def test_run_on_stream(self):
+        linter.run(io.StringIO(u'hello'), self.fake_config())
+
+    def test_run_on_int(self):
+        self.assertRaises(TypeError, linter.run, 42, self.fake_config())
+
+    def test_run_on_list(self):
+        self.assertRaises(TypeError, linter.run,
+                          ['h', 'e', 'l', 'l', 'o'], self.fake_config())
+
+    def test_run_on_non_ascii_chars(self):
+        s = (u'- hétérogénéité\n'
+             u'# 19.99 €\n')
+        linter.run(s, self.fake_config())
+        linter.run(s.encode('utf-8'), self.fake_config())
+        linter.run(s.encode('iso-8859-15'), self.fake_config())
+
+        s = (u'- お早う御座います。\n'
+             u'# الأَبْجَدِيَّة العَرَبِيَّة\n')
+        linter.run(s, self.fake_config())
+        linter.run(s.encode('utf-8'), self.fake_config())

tests/test_module.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 Adrien Vergé
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import shutil
+import subprocess
+import tempfile
+import sys
+import unittest
+
+
+PYTHON = sys.executable or 'python'
+
+
+class ModuleTestCase(unittest.TestCase):
+    def setUp(self):
+        self.wd = tempfile.mkdtemp(prefix='yamllint-tests-')
+
+        # file with only one warning
+        with open(os.path.join(self.wd, 'warn.yaml'), 'w') as f:
+            f.write('key: value\n')
+
+        # file in dir
+        os.mkdir(os.path.join(self.wd, 'sub'))
+        with open(os.path.join(self.wd, 'sub', 'nok.yaml'), 'w') as f:
+            f.write('---\n'
+                    'list: [  1, 1, 2, 3, 5, 8]  \n')
+
+    def tearDown(self):
+        shutil.rmtree(self.wd)
+
+    def test_run_module_no_args(self):
+        with self.assertRaises(subprocess.CalledProcessError) as ctx:
+            subprocess.check_output([PYTHON, '-m', 'yamllint'],
+                                    stderr=subprocess.STDOUT)
+        self.assertEqual(ctx.exception.returncode, 2)
+        self.assertRegexpMatches(ctx.exception.output.decode(),
+                                 r'^usage: yamllint')
+
+    def test_run_module_on_bad_dir(self):
+        with self.assertRaises(subprocess.CalledProcessError) as ctx:
+            subprocess.check_output([PYTHON, '-m', 'yamllint',
+                                     '/does/not/exist'],
+                                    stderr=subprocess.STDOUT)
+        self.assertRegexpMatches(ctx.exception.output.decode(),
+                                 r'No such file or directory')
+
+    def test_run_module_on_file(self):
+        out = subprocess.check_output(
+            [PYTHON, '-m', 'yamllint', os.path.join(self.wd, 'warn.yaml')])
+        lines = out.decode().splitlines()
+        self.assertIn('/warn.yaml', lines[0])
+        self.assertEqual('\n'.join(lines[1:]),
+                         '  1:1       warning  missing document start "---"'
+                         '  (document-start)\n')
+
+    def test_run_module_on_dir(self):
+        with self.assertRaises(subprocess.CalledProcessError) as ctx:
+            subprocess.check_output([PYTHON, '-m', 'yamllint', self.wd])
+        self.assertEqual(ctx.exception.returncode, 1)
+
+        files = ctx.exception.output.decode().split('\n\n')
+        self.assertIn(
+            '/warn.yaml\n'
+            '  1:1       warning  missing document start "---"'
+            '  (document-start)',
+            files[0])
+        self.assertIn(
+            '/sub/nok.yaml\n'
+            '  2:9       error    too many spaces inside brackets'
+            '  (brackets)\n'
+            '  2:27      error    trailing spaces  (trailing-spaces)',
+            files[1])

tests/test_parser.py

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

tests/test_spec_examples.py

@@ -14,6 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+from io import open
 import os
 
 from tests.common import RuleTestCase
@@ -35,6 +36,7 @@ from tests.common import RuleTestCase
 #             for br in span.find_all("br"):
 #                 br.replace_with("\n")
 #             text = text.replace('\u2193', '')    # downwards arrow
+#             text = text.replace('\u21d3', '')    # double downwards arrow
 #             text = text.replace('\u00b7', ' ')   # visible space
 #             text = text.replace('\u21d4', '')    # byte order mark
 #             text = text.replace('\u2192', '\t')  # right arrow
@@ -46,13 +48,14 @@ from tests.common import RuleTestCase
 class SpecificationTestCase(RuleTestCase):
     rule_id = None
 
+
 conf_general = ('document-start: disable\n'
                 'comments: {min-spaces-from-content: 1}\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'),
@@ -60,60 +63,69 @@ 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: no}\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.17': ('indentation: disable\n'),
+    'example-7.16': 'indentation: disable\n',
-    'example-7.18': ('indentation: disable\n'),
+    'example-7.17': 'indentation: disable\n',
-    'example-7.19': ('indentation: disable\n'),
+    'example-7.18': 'indentation: disable\n',
+    'example-7.19': 'indentation: disable\n',
     'example-7.20': ('colons: {max-spaces-before: 1}\n'
                      'indentation: disable\n'),
-    'example-8.1': ('empty-lines: {max-end: 1}\n'),
+    'example-8.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-10.1': 'colons: {max-spaces-before: 2}\n',
+    'example-10.2': 'indentation: {indent-sequences: false}\n',
+    'example-10.8': 'truthy: disable\n',
+    'example-10.9': 'truthy: disable\n',
 }
 
-files = os.listdir('tests/yaml-1.2-spec-examples')
+files = os.listdir(os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                                'yaml-1.2-spec-examples'))
 assert len(files) == 132
 
 
@@ -122,15 +134,7 @@ def _gen_test(buffer, conf):
         self.check(buffer, conf)
     return test
 
-# TODO
+
-# The following tests are blacklisted because they contain rarely-used formats
-# that yamllint does not handle yet.
-tmp_blacklist = (
-    'example-7.16',
-    'example-8.20',
-    'example-8.22',
-    'example-10.1',
-)
 # The following tests are blacklisted (i.e. will not be checked against
 # yamllint), because pyyaml is currently not able to parse the contents
 # (using yaml.parse()).
@@ -177,10 +181,10 @@ pyyaml_blacklist = (
 )
 
 for file in files:
-    if file in tmp_blacklist or file in pyyaml_blacklist:
+    if file in pyyaml_blacklist:
         continue
 
-    with open('tests/yaml-1.2-spec-examples/' + file) as f:
+    with open('tests/yaml-1.2-spec-examples/' + file, encoding='utf-8') as f:
         conf = conf_general + conf_overrides.get(file, '')
         setattr(SpecificationTestCase, 'test_' + file,
                 _gen_test(f.read(), conf))

tests/test_yamllint_directives.py

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

tests/yaml-1.2-spec-examples/example-8.5

@@ -2,7 +2,7 @@
   # Comments:
 strip: |-
   # text
-  ⇓
+  
  # Clip
   # comments:
 

yamllint/__init__.py

@@ -14,12 +14,16 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-APP_NAME = 'yamllint'
+"""A linter for YAML files.
-APP_VERSION = '0.7.0'
-APP_DESCRIPTION = """A linter for YAML files.
 
-yamllint does not only check for syntax validity, but for common cosmetic
+yamllint does not only check for syntax validity, but for weirdnesses like key
-conventions such as lines length, trailing spaces, indentation, etc."""
+repetition and cosmetic problems such as lines length, trailing spaces,
+indentation, etc."""
+
+
+APP_NAME = 'yamllint'
+APP_VERSION = '1.22.1'
+APP_DESCRIPTION = __doc__
 
 __author__ = u'Adrien Vergé'
 __copyright__ = u'Copyright 2016, Adrien Vergé'

yamllint/__main__.py

@@ -0,0 +1,4 @@
+from yamllint.cli import run
+
+if __name__ == '__main__':
+    run()

yamllint/cli.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
@@ -16,27 +15,40 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import print_function
-import os.path
-import sys
 
 import argparse
+import io
+import os
+import platform
+import sys
 
 from yamllint import APP_DESCRIPTION, APP_NAME, APP_VERSION
-from yamllint.config import YamlLintConfig, YamlLintConfigError
 from yamllint import linter
+from yamllint.config import YamlLintConfig, YamlLintConfigError
+from yamllint.linter import PROBLEM_LEVELS
 
 
-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
 
 
+def supports_color():
+    supported_platform = not (platform.system() == 'Windows' and not
+                              ('ANSICON' in os.environ or
+                               ('TERM' in os.environ and
+                                os.environ['TERM'] == 'ANSI')))
+    return (supported_platform and
+            hasattr(sys.stdout, 'isatty') and sys.stdout.isatty())
+
+
 class Format(object):
     @staticmethod
     def parsable(problem, filename):
@@ -49,6 +61,17 @@ class Format(object):
 
     @staticmethod
     def standard(problem, filename):
+        line = '  %d:%d' % (problem.line, problem.column)
+        line += max(12 - len(line), 0) * ' '
+        line += problem.level
+        line += max(21 - len(line), 0) * ' '
+        line += problem.desc
+        if problem.rule:
+            line += '  (%s)' % problem.rule
+        return line
+
+    @staticmethod
+    def standard_color(problem, filename):
         line = '  \033[2m%d:%d\033[0m' % (problem.line, problem.column)
         line += max(20 - len(line), 0) * ' '
         if problem.level == 'warning':
@@ -62,57 +85,123 @@ 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='*',
-    parser.add_argument('-c', '--config', dest='config_file', action='store',
+                             default=(),
-                        help='path to a custom configuration')
+                             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',
+                              help='path to a custom configuration')
+    config_group.add_argument('-d', '--config-data', dest='config_data',
+                              action='store',
+                              help='custom configuration (as YAML source)')
     parser.add_argument('-f', '--format',
-                        choices=('parsable', 'standard'), default='standard',
+                        choices=('parsable', 'standard', 'colored', 'auto'),
-                        help='format for parsing output')
+                        default='auto', help='format for parsing output')
+    parser.add_argument('-s', '--strict',
+                        action='store_true',
+                        help='return non-zero exit code on warnings '
+                             'as well as errors')
+    parser.add_argument('--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)
 
+    # User-global config is supposed to be in ~/.config/yamllint/config
+    if 'XDG_CONFIG_HOME' in os.environ:
+        user_global_config = os.path.join(
+            os.environ['XDG_CONFIG_HOME'], 'yamllint', 'config')
+    else:
+        user_global_config = os.path.expanduser('~/.config/yamllint/config')
+
     try:
-        if args.config_file is not None:
+        if args.config_data is not None:
+            if args.config_data != '' and ':' not in args.config_data:
+                args.config_data = 'extends: ' + args.config_data
+            conf = YamlLintConfig(content=args.config_data)
+        elif args.config_file is not None:
             conf = YamlLintConfig(file=args.config_file)
         elif os.path.isfile('.yamllint'):
             conf = YamlLintConfig(file='.yamllint')
+        elif 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:
             conf = YamlLintConfig('extends: default')
     except YamlLintConfigError as e:
         print(e, file=sys.stderr)
         sys.exit(-1)
 
-    return_code = 0
+    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):
-                    if args.format == 'parsable':
-                        print(Format.parsable(problem, file))
-                    else:
-                        if first:
-                            print('\033[4m%s\033[0m' % file)
-                            first = False
-
-                        print(Format.standard(problem, file))
-
-                    if return_code == 0 and problem.level == 'error':
-                        return_code = 1
-
-            if not first and args.format != 'parsable':
-                print('')
         except EnvironmentError as e:
-            print(e)
+            print(e, file=sys.stderr)
-            return_code = -1
+            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
+    elif max_level == PROBLEM_LEVELS['warning']:
+        return_code = 2 if args.strict else 0
+    else:
+        return_code = 0
 
     sys.exit(return_code)

yamllint/conf/default.yaml

@@ -0,0 +1,33 @@
+---
+
+yaml-files:
+  - '*.yaml'
+  - '*.yml'
+  - '.yamllint'
+
+rules:
+  braces: enable
+  brackets: enable
+  colons: enable
+  commas: enable
+  comments:
+    level: warning
+  comments-indentation:
+    level: warning
+  document-end: disable
+  document-start:
+    level: warning
+  empty-lines: enable
+  empty-values: disable
+  hyphens: enable
+  indentation: enable
+  key-duplicates: enable
+  key-ordering: disable
+  line-length: enable
+  new-line-at-end-of-file: enable
+  new-lines: enable
+  octal-values: disable
+  quoted-strings: disable
+  trailing-spaces: enable
+  truthy:
+    level: warning

yamllint/conf/default.yml

@@ -1,44 +0,0 @@
----
-
-rules:
-  braces:
-    min-spaces-inside: 0
-    max-spaces-inside: 0
-  brackets:
-    min-spaces-inside: 0
-    max-spaces-inside: 0
-  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: yes
-    min-spaces-from-content: 2
-  comments-indentation:
-    level: warning
-  document-end: disable
-  document-start:
-    level: warning
-    present: yes
-  empty-lines:
-    max: 2
-    max-start: 0
-    max-end: 0
-  hyphens:
-    max-spaces-after: 1
-  indentation:
-    spaces: 2
-    indent-sequences: yes
-    check-multi-line-strings: no
-  key-duplicates: {}
-  line-length:
-    max: 80
-    allow-non-breakable-words: yes
-  new-line-at-end-of-file: {level: error}
-  new-lines:
-    type: unix
-  trailing-spaces: {}

yamllint/conf/relaxed.yaml

@@ -0,0 +1,29 @@
+---
+
+extends: default
+
+rules:
+  braces:
+    level: warning
+    max-spaces-inside: 1
+  brackets:
+    level: warning
+    max-spaces-inside: 1
+  colons:
+    level: warning
+  commas:
+    level: warning
+  comments: disable
+  comments-indentation: disable
+  document-start: disable
+  empty-lines:
+    level: warning
+  hyphens:
+    level: warning
+  indentation:
+    level: warning
+    indent-sequences: consistent
+  line-length:
+    level: warning
+    allow-non-breakable-inline-mappings: true
+  truthy: disable

yamllint/config.py

@@ -16,6 +16,7 @@
 
 import os.path
 
+import pathspec
 import yaml
 
 import yamllint.rules
@@ -29,6 +30,11 @@ class YamlLintConfig(object):
     def __init__(self, content=None, file=None):
         assert (content is None) ^ (file is None)
 
+        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()
@@ -36,15 +42,23 @@ class YamlLintConfig(object):
         self.parse(content)
         self.validate()
 
-    def enabled_rules(self):
+    def is_file_ignored(self, filepath):
+        return self.ignore and self.ignore.match_file(filepath)
+
+    def 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]
+                if val is not False and (
+                    filepath is None or 'ignore' not in val or
+                    not val['ignore'].match_file(filepath))]
 
     def extend(self, base_config):
         assert isinstance(base_config, YamlLintConfig)
 
         for rule in self.rules:
-            if (type(self.rules[rule]) == dict and
+            if (isinstance(self.rules[rule], dict) and
                     rule in base_config.rules and
                     base_config.rules[rule] is not False):
                 base_config.rules[rule].update(self.rules[rule])
@@ -53,13 +67,24 @@ class YamlLintConfig(object):
 
         self.rules = base_config.rules
 
+        if base_config.ignore is not None:
+            self.ignore = base_config.ignore
+
     def parse(self, raw_content):
         try:
             conf = yaml.safe_load(raw_content)
         except Exception as e:
             raise YamlLintConfigError('invalid config: %s' % e)
 
+        if not isinstance(conf, dict):
+            raise YamlLintConfigError('invalid config: not a dict')
+
         self.rules = conf.get('rules', {})
+        for rule in self.rules:
+            if self.rules[rule] == 'enable':
+                self.rules[rule] = {}
+            elif self.rules[rule] == 'disable':
+                self.rules[rule] = False
 
         # Does this conf override another conf that we need to load?
         if 'extends' in conf:
@@ -70,6 +95,22 @@ class YamlLintConfig(object):
             except Exception as e:
                 raise YamlLintConfigError('invalid config: %s' % e)
 
+        if 'ignore' in conf:
+            if not isinstance(conf['ignore'], str):
+                raise YamlLintConfigError(
+                    'invalid config: ignore should contain file patterns')
+            self.ignore = pathspec.PathSpec.from_lines(
+                'gitwildmatch', conf['ignore'].splitlines())
+
+        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:
@@ -81,10 +122,18 @@ class YamlLintConfig(object):
 
 
 def validate_rule_conf(rule, conf):
-    if conf is False or conf == 'disable':
+    if conf is False:  # disable
         return False
 
-    if type(conf) == dict:
+    if isinstance(conf, dict):
+        if ('ignore' in conf and
+                not isinstance(conf['ignore'], pathspec.pathspec.PathSpec)):
+            if not isinstance(conf['ignore'], str):
+                raise YamlLintConfigError(
+                    'invalid config: ignore should contain file patterns')
+            conf['ignore'] = pathspec.PathSpec.from_lines(
+                'gitwildmatch', conf['ignore'].splitlines())
+
         if 'level' not in conf:
             conf['level'] = 'error'
         elif conf['level'] not in ('error', 'warning'):
@@ -92,31 +141,46 @@ def validate_rule_conf(rule, conf):
                 'invalid config: level should be "error" or "warning"')
 
         options = getattr(rule, 'CONF', {})
+        options_default = getattr(rule, 'DEFAULT', {})
         for optkey in conf:
-            if optkey == 'level':
+            if optkey in ('ignore', 'level'):
                 continue
             if optkey not in options:
                 raise YamlLintConfigError(
                     'invalid config: unknown option "%s" for rule "%s"' %
                     (optkey, rule.ID))
-            if type(options[optkey]) == tuple:
+            # Example: CONF = {option: (bool, 'mixed')}
-                if conf[optkey] not in options[optkey]:
+            #          → {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 type(conf[optkey]) != options[optkey]:
+                if not isinstance(conf[optkey], options[optkey]):
                     raise YamlLintConfigError(
                         'invalid config: option "%s" of "%s" should be %s'
                         % (optkey, rule.ID, options[optkey].__name__))
         for optkey in options:
             if optkey not in conf:
-                raise YamlLintConfigError(
+                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 "disable" or a dict') % rule.ID)
+                                   'either "enable", "disable" or a dict')
+                                  % rule.ID)
 
     return conf
 
@@ -125,7 +189,7 @@ def get_extended_config_file(name):
     # Is it a standard conf shipped with yamllint...
     if '/' not in name:
         std_conf = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                'conf', name + '.yml')
+                                'conf', name + '.yaml')
 
         if os.path.isfile(std_conf):
             return std_conf

yamllint/linter.py

@@ -14,11 +14,23 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import re
+
 import yaml
 
 from yamllint import parser
 
 
+PROBLEM_LEVELS = {
+    0: None,
+    1: 'warning',
+    2: 'error',
+    None: 0,
+    'warning': 1,
+    'error': 2,
+}
+
+
 class LintProblem(object):
     """Represents a linting problem found by yamllint."""
     def __init__(self, line, column, desc='<no description>', rule=None):
@@ -35,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):
@@ -51,35 +63,116 @@ class LintProblem(object):
         return '%d:%d: %s' % (self.line, self.column, self.message)
 
 
-def get_costemic_problems(buffer, conf):
+def get_cosmetic_problems(buffer, conf, filepath):
-    rules = conf.enabled_rules()
+    rules = conf.enabled_rules(filepath)
 
     # Split token rules from line rules
     token_rules = [r for r in rules if r.TYPE == 'token']
+    comment_rules = [r for r in rules if r.TYPE == 'comment']
     line_rules = [r for r in rules if r.TYPE == 'line']
 
     context = {}
     for rule in token_rules:
         context[rule.ID] = {}
 
-    for elem in parser.token_or_line_generator(buffer):
+    class DisableDirective:
+        def __init__(self):
+            self.rules = set()
+            self.all_rules = {r.ID for r in rules}
+
+        def process_comment(self, comment):
+            try:
+                comment = str(comment)
+            except UnicodeError:
+                return  # this certainly wasn't a yamllint directive comment
+
+            if re.match(r'^# yamllint disable( rule:\S+)*\s*$', comment):
+                rules = [item[5:] for item in comment[18:].split(' ')][1:]
+                if len(rules) == 0:
+                    self.rules = self.all_rules.copy()
+                else:
+                    for id in rules:
+                        if id in self.all_rules:
+                            self.rules.add(id)
+
+            elif re.match(r'^# yamllint enable( rule:\S+)*\s*$', comment):
+                rules = [item[5:] for item in comment[17:].split(' ')][1:]
+                if len(rules) == 0:
+                    self.rules.clear()
+                else:
+                    for id in rules:
+                        self.rules.discard(id)
+
+        def is_disabled_by_directive(self, problem):
+            return problem.rule in self.rules
+
+    class DisableLineDirective(DisableDirective):
+        def process_comment(self, comment):
+            try:
+                comment = str(comment)
+            except UnicodeError:
+                return  # this certainly wasn't a yamllint directive comment
+
+            if re.match(r'^# yamllint disable-line( rule:\S+)*\s*$', comment):
+                rules = [item[5:] for item in comment[23:].split(' ')][1:]
+                if len(rules) == 0:
+                    self.rules = self.all_rules.copy()
+                else:
+                    for id in rules:
+                        if id in self.all_rules:
+                            self.rules.add(id)
+
+    # Use a cache to store problems and flush it only when a end of line is
+    # found. This allows the use of yamllint directive to disable some rules on
+    # some lines.
+    cache = []
+    disabled = DisableDirective()
+    disabled_for_line = DisableLineDirective()
+    disabled_for_next_line = DisableLineDirective()
+
+    for elem in parser.token_or_comment_or_line_generator(buffer):
         if isinstance(elem, parser.Token):
             for rule in token_rules:
                 rule_conf = conf.rules[rule.ID]
                 for problem in rule.check(rule_conf,
                                           elem.curr, elem.prev, elem.next,
+                                          elem.nextnext,
                                           context[rule.ID]):
                     problem.rule = rule.ID
                     problem.level = rule_conf['level']
-                    yield problem
+                    cache.append(problem)
+        elif isinstance(elem, parser.Comment):
+            for rule in comment_rules:
+                rule_conf = conf.rules[rule.ID]
+                for problem in rule.check(rule_conf, elem):
+                    problem.rule = rule.ID
+                    problem.level = rule_conf['level']
+                    cache.append(problem)
+
+            disabled.process_comment(elem)
+            if elem.is_inline():
+                disabled_for_line.process_comment(elem)
+            else:
+                disabled_for_next_line.process_comment(elem)
         elif isinstance(elem, parser.Line):
             for rule in line_rules:
                 rule_conf = conf.rules[rule.ID]
                 for problem in rule.check(rule_conf, elem):
                     problem.rule = rule.ID
                     problem.level = rule_conf['level']
+                    cache.append(problem)
+
+            # This is the last token/comment/line of this line, let's flush the
+            # problems found (but filter them according to the directives)
+            for problem in cache:
+                if not (disabled_for_line.is_disabled_by_directive(problem) or
+                        disabled.is_disabled_by_directive(problem)):
                     yield problem
 
+            disabled_for_line = disabled_for_next_line
+            disabled_for_next_line = DisableLineDirective()
+            cache = []
+
 
 def get_syntax_error(buffer):
     try:
@@ -87,17 +180,24 @@ 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
 
 
-def _run(buffer, conf):
+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)
 
-    for problem in get_costemic_problems(buffer, conf):
+    for problem in get_cosmetic_problems(buffer, conf, filepath):
         # Insert the syntax error (if any) at the right place...
         if (syntax_error and syntax_error.line <= problem.line and
                 syntax_error.column <= problem.column):
@@ -119,7 +219,7 @@ def _run(buffer, conf):
         yield syntax_error
 
 
-def run(input, conf):
+def run(input, conf, filepath=None):
     """Lints a YAML source.
 
     Returns a generator of LintProblem objects.
@@ -127,11 +227,14 @@ def run(input, conf):
     :param input: buffer, string or stream to read from
     :param conf: yamllint configuration object
     """
-    if type(input) == str:
+    if conf.is_file_ignored(filepath):
-        return _run(input, conf)
+        return ()
+
+    if isinstance(input, (type(b''), type(u''))):  # compat with Python 2 & 3
+        return _run(input, conf, filepath)
     elif hasattr(input, 'read'):  # Python 2's file or Python 3's io.IOBase
         # We need to have everything in memory to parse correctly
         content = input.read()
-        return _run(content, conf)
+        return _run(content, conf, filepath)
     else:
         raise TypeError('input should be a string or a stream')

yamllint/parser.py

@@ -30,11 +30,46 @@ class Line(object):
 
 
 class Token(object):
-    def __init__(self, line_no, curr, prev, next):
+    def __init__(self, line_no, curr, prev, next, nextnext):
         self.line_no = line_no
         self.curr = curr
         self.prev = prev
         self.next = next
+        self.nextnext = nextnext
+
+
+class Comment(object):
+    def __init__(self, line_no, column_no, buffer, pointer,
+                 token_before=None, token_after=None, comment_before=None):
+        self.line_no = line_no
+        self.column_no = column_no
+        self.buffer = buffer
+        self.pointer = pointer
+        self.token_before = token_before
+        self.token_after = token_after
+        self.comment_before = comment_before
+
+    def __str__(self):
+        end = self.buffer.find('\n', self.pointer)
+        if end == -1:
+            end = self.buffer.find('\0', self.pointer)
+        if end != -1:
+            return self.buffer[self.pointer:end]
+        return self.buffer[self.pointer:]
+
+    def __eq__(self, other):
+        return (isinstance(other, Comment) and
+                self.line_no == other.line_no and
+                self.column_no == other.column_no and
+                str(self) == str(other))
+
+    def is_inline(self):
+        return (
+            not isinstance(self.token_before, yaml.StreamStartToken) and
+            self.line_no == self.token_before.end_mark.line + 1 and
+            # sometimes token end marks are on the next line
+            self.buffer[self.token_before.end_mark.pointer - 1] != '\n'
+        )
 
 
 def line_generator(buffer):
@@ -42,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
@@ -50,36 +88,74 @@ def line_generator(buffer):
     yield Line(line_no, buffer, start=cur, end=len(buffer))
 
 
-def token_generator(buffer):
+def comments_between_tokens(token1, token2):
+    """Find all comments between two tokens"""
+    if token2 is None:
+        buf = token1.end_mark.buffer[token1.end_mark.pointer:]
+    elif (token1.end_mark.line == token2.start_mark.line and
+          not isinstance(token1, yaml.StreamStartToken) and
+          not isinstance(token2, yaml.StreamEndToken)):
+        return
+    else:
+        buf = token1.end_mark.buffer[token1.end_mark.pointer:
+                                     token2.start_mark.pointer]
+
+    line_no = token1.end_mark.line + 1
+    column_no = token1.end_mark.column + 1
+    pointer = token1.end_mark.pointer
+
+    comment_before = None
+    for line in buf.split('\n'):
+        pos = line.find('#')
+        if pos != -1:
+            comment = Comment(line_no, column_no + pos,
+                              token1.end_mark.buffer, pointer + pos,
+                              token1, token2, comment_before)
+            yield comment
+
+            comment_before = comment
+
+        pointer += len(line) + 1
+        line_no += 1
+        column_no = 1
+
+
+def token_or_comment_generator(buffer):
     yaml_loader = yaml.BaseLoader(buffer)
 
     try:
         prev = None
-        next = yaml_loader.peek_token()
+        curr = yaml_loader.get_token()
-        while next is not None:
+        while curr is not None:
-            curr = yaml_loader.get_token()
+            next = yaml_loader.get_token()
-            next = yaml_loader.peek_token()
+            nextnext = (yaml_loader.peek_token()
+                        if yaml_loader.check_token() else None)
 
-            yield Token(curr.start_mark.line + 1, curr, prev, next)
+            yield Token(curr.start_mark.line + 1, curr, prev, next, nextnext)
+
+            for comment in comments_between_tokens(curr, next):
+                yield comment
 
             prev = curr
+            curr = next
+
     except yaml.scanner.ScannerError:
         pass
 
 
-def token_or_line_generator(buffer):
+def token_or_comment_or_line_generator(buffer):
     """Generator that mixes tokens and lines, ordering them by line number"""
-    token_gen = token_generator(buffer)
+    tok_or_com_gen = token_or_comment_generator(buffer)
     line_gen = line_generator(buffer)
 
-    token = next(token_gen, None)
+    tok_or_com = next(tok_or_com_gen, None)
     line = next(line_gen, None)
 
-    while token is not None or line is not None:
+    while tok_or_com is not None or line is not None:
-        if token is None or (line is not None and
+        if tok_or_com is None or (line is not None and
-                             token.line_no > line.line_no):
+                                  tok_or_com.line_no > line.line_no):
             yield line
             line = next(line_gen, None)
         else:
-            yield token
+            yield tok_or_com
-            token = next(token_gen, None)
+            tok_or_com = next(tok_or_com_gen, None)

yamllint/rules/__init__.py

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

yamllint/rules/braces.py

@@ -23,6 +23,10 @@ Use this rule to control the number of spaces inside braces (``{`` and ``}``).
   braces.
 * ``max-spaces-inside`` defines the maximal number of spaces allowed inside
   braces.
+* ``min-spaces-inside-empty`` defines the minimal number of spaces required
+  inside empty braces.
+* ``max-spaces-inside-empty`` defines the maximal number of spaces allowed
+  inside empty braces.
 
 .. rubric:: Examples
 
@@ -59,6 +63,30 @@ Use this rule to control the number of spaces inside braces (``{`` and ``}``).
    ::
 
     object: {key1: 4, key2: 8 }
+
+#. With ``braces: {min-spaces-inside-empty: 0, max-spaces-inside-empty: 0}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    object: {}
+
+   the following code snippet would **FAIL**:
+   ::
+
+    object: { }
+
+#. With ``braces: {min-spaces-inside-empty: 1, max-spaces-inside-empty: -1}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    object: {         }
+
+   the following code snippet would **FAIL**:
+   ::
+
+    object: {}
 """
 
 
@@ -70,11 +98,31 @@ from yamllint.rules.common import spaces_after, spaces_before
 ID = 'braces'
 TYPE = 'token'
 CONF = {'min-spaces-inside': int,
-        'max-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, context):
+def check(conf, token, prev, next, nextnext, context):
-    if isinstance(token, yaml.FlowMappingStartToken):
+    if (isinstance(token, yaml.FlowMappingStartToken) and
+            isinstance(next, yaml.FlowMappingEndToken)):
+        problem = spaces_after(token, prev, next,
+                               min=(conf['min-spaces-inside-empty']
+                                    if conf['min-spaces-inside-empty'] != -1
+                                    else conf['min-spaces-inside']),
+                               max=(conf['max-spaces-inside-empty']
+                                    if conf['max-spaces-inside-empty'] != -1
+                                    else conf['max-spaces-inside']),
+                               min_desc='too few spaces inside empty braces',
+                               max_desc='too many spaces inside empty braces')
+        if problem is not None:
+            yield problem
+
+    elif isinstance(token, yaml.FlowMappingStartToken):
         problem = spaces_after(token, prev, next,
                                min=conf['min-spaces-inside'],
                                max=conf['max-spaces-inside'],

yamllint/rules/brackets.py

@@ -24,6 +24,10 @@ Use this rule to control the number of spaces inside brackets (``[`` and
   brackets.
 * ``max-spaces-inside`` defines the maximal number of spaces allowed inside
   brackets.
+* ``min-spaces-inside-empty`` defines the minimal number of spaces required
+  inside empty brackets.
+* ``max-spaces-inside-empty`` defines the maximal number of spaces allowed
+  inside empty brackets.
 
 .. rubric:: Examples
 
@@ -60,6 +64,30 @@ Use this rule to control the number of spaces inside brackets (``[`` and
    ::
 
     object: [1, 2, abc ]
+
+#. With ``brackets: {min-spaces-inside-empty: 0, max-spaces-inside-empty: 0}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    object: []
+
+   the following code snippet would **FAIL**:
+   ::
+
+    object: [ ]
+
+#. With ``brackets: {min-spaces-inside-empty: 1, max-spaces-inside-empty: -1}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    object: [         ]
+
+   the following code snippet would **FAIL**:
+   ::
+
+    object: []
 """
 
 
@@ -71,11 +99,32 @@ from yamllint.rules.common import spaces_after, spaces_before
 ID = 'brackets'
 TYPE = 'token'
 CONF = {'min-spaces-inside': int,
-        'max-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, context):
+def check(conf, token, prev, next, nextnext, context):
-    if isinstance(token, yaml.FlowSequenceStartToken):
+    if (isinstance(token, yaml.FlowSequenceStartToken) and
+            isinstance(next, yaml.FlowSequenceEndToken)):
+        problem = spaces_after(token, prev, next,
+                               min=(conf['min-spaces-inside-empty']
+                                    if conf['min-spaces-inside-empty'] != -1
+                                    else conf['min-spaces-inside']),
+                               max=(conf['max-spaces-inside-empty']
+                                    if conf['max-spaces-inside-empty'] != -1
+                                    else conf['max-spaces-inside']),
+                               min_desc='too few spaces inside empty brackets',
+                               max_desc=('too many spaces inside empty '
+                                         'brackets'))
+        if problem is not None:
+            yield problem
+
+    elif isinstance(token, yaml.FlowSequenceStartToken):
         problem = spaces_after(token, prev, next,
                                min=conf['min-spaces-inside'],
                                max=conf['max-spaces-inside'],

yamllint/rules/colons.py

@@ -72,16 +72,18 @@ 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, context):
+def check(conf, token, prev, next, nextnext, context):
     if isinstance(token, yaml.ValueToken):
         problem = spaces_before(token, prev, next,
                                 max=conf['max-spaces-before'],

yamllint/rules/commas.py

@@ -103,9 +103,12 @@ 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, context):
+def check(conf, token, prev, next, nextnext, context):
     if isinstance(token, yaml.FlowEntryToken):
         if (prev is not None and conf['max-spaces-before'] != -1 and
                 prev.end_mark.line < token.start_mark.line):

yamllint/rules/comments.py

@@ -20,14 +20,17 @@ Use this rule to control the position and formatting of comments.
 .. rubric:: Options
 
 * Use ``require-starting-space`` to require a space character right after the
-  ``#``. Set to ``yes`` to enable, ``no`` to disable.
+  ``#``. 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.
 
 .. rubric:: Examples
 
-#. With ``comments: {require-starting-space: yes}``
+#. With ``comments: {require-starting-space: true}``
 
    the following code snippet would **PASS**:
    ::
@@ -35,6 +38,12 @@ Use this rule to control the position and formatting of comments.
     # This sentence
     # is a block comment
 
+   the following code snippet would **PASS**:
+   ::
+
+    ##############################
+    ## This is some documentation
+
    the following code snippet would **FAIL**:
    ::
 
@@ -55,33 +64,41 @@ Use this rule to control the position and formatting of comments.
 """
 
 
-import yaml
+import re
 
 from yamllint.linter import LintProblem
-from yamllint.rules.common import get_comments_between_tokens
 
 
 ID = 'comments'
-TYPE = 'token'
+TYPE = 'comment'
 CONF = {'require-starting-space': bool,
+        'ignore-shebangs': bool,
         'min-spaces-from-content': int}
+DEFAULT = {'require-starting-space': True,
+           'ignore-shebangs': True,
+           'min-spaces-from-content': 2}
 
 
-def check(conf, token, prev, next, context):
+def check(conf, comment):
-    for comment in get_comments_between_tokens(token, next):
+    if (conf['min-spaces-from-content'] != -1 and comment.is_inline() and
-        if (conf['min-spaces-from-content'] != -1 and
+            comment.pointer - comment.token_before.end_mark.pointer <
-                not isinstance(token, yaml.StreamStartToken) and
+            conf['min-spaces-from-content']):
-                comment.line == token.end_mark.line + 1):
+        yield LintProblem(comment.line_no, comment.column_no,
-            # Sometimes token end marks are on the next line
+                          'too few spaces before comment')
-            if token.end_mark.buffer[token.end_mark.pointer - 1] != '\n':
-                if (comment.pointer - token.end_mark.pointer <
-                        conf['min-spaces-from-content']):
-                    yield LintProblem(comment.line, comment.column,
-                                      'too few spaces before comment')
 
-        if (conf['require-starting-space'] and
+    if conf['require-starting-space']:
-                comment.pointer + 1 < len(comment.buffer) and
+        text_start = comment.pointer + 1
-                comment.buffer[comment.pointer + 1] != ' ' and
+        while (comment.buffer[text_start] == '#' and
-                comment.buffer[comment.pointer + 1] != '\n'):
+               text_start < len(comment.buffer)):
-            yield LintProblem(comment.line, comment.column + 1,
+            text_start += 1
-                              'missing starting space in comment')
+        if text_start < len(comment.buffer):
+            if (conf['ignore-shebangs'] and
+                    comment.line_no == 1 and
+                    comment.column_no == 1 and
+                    re.match(r'^!\S', comment.buffer[text_start:])):
+                return
+            elif comment.buffer[text_start] not in (' ', '\n', '\0'):
+                column = comment.column_no + text_start - comment.pointer
+                yield LintProblem(comment.line_no,
+                                  column,
+                                  'missing starting space in comment')

yamllint/rules/comments_indentation.py

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

yamllint/rules/common.py

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

yamllint/rules/document_end.py

@@ -19,12 +19,12 @@ Use this rule to require or forbid the use of document end marker (``...``).
 
 .. rubric:: Options
 
-* Set ``present`` to ``yes`` when the document end marker is required, or to
+* Set ``present`` to ``true`` when the document end marker is required, or to
-  ``no`` when it is forbidden.
+  ``false`` when it is forbidden.
 
 .. rubric:: Examples
 
-#. With ``document-end: {present: yes}``
+#. With ``document-end: {present: true}``
 
    the following code snippet would **PASS**:
    ::
@@ -49,7 +49,7 @@ Use this rule to require or forbid the use of document end marker (``...``).
     - is: another one
     ...
 
-#. With ``document-end: {present: no}``
+#. With ``document-end: {present: false}``
 
    the following code snippet would **PASS**:
    ::
@@ -82,18 +82,21 @@ from yamllint.linter import LintProblem
 ID = 'document-end'
 TYPE = 'token'
 CONF = {'present': bool}
+DEFAULT = {'present': True}
 
 
-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
     if conf['present']:
-        if (isinstance(token, yaml.StreamEndToken) and
+        is_stream_end = isinstance(token, yaml.StreamEndToken)
-                not (isinstance(prev, yaml.DocumentEndToken) or
+        is_start = isinstance(token, yaml.DocumentStartToken)
-                     isinstance(prev, yaml.StreamStartToken))):
+        prev_is_end_or_stream_start = isinstance(
+            prev, (yaml.DocumentEndToken, yaml.StreamStartToken)
+        )
+
+        if is_stream_end and not prev_is_end_or_stream_start:
             yield LintProblem(token.start_mark.line, 1,
                               'missing document end "..."')
-        elif (isinstance(token, yaml.DocumentStartToken) and
+        elif is_start and not prev_is_end_or_stream_start:
-                not (isinstance(prev, yaml.DocumentEndToken) or
-                     isinstance(prev, yaml.StreamStartToken))):
             yield LintProblem(token.start_mark.line + 1, 1,
                               'missing document end "..."')
 

yamllint/rules/document_start.py

@@ -19,12 +19,12 @@ Use this rule to require or forbid the use of document start marker (``---``).
 
 .. rubric:: Options
 
-* Set ``present`` to ``yes`` when the document start marker is required, or to
+* Set ``present`` to ``true`` when the document start marker is required, or to
-  ``no`` when it is forbidden.
+  ``false`` when it is forbidden.
 
 .. rubric:: Examples
 
-#. With ``document-start: {present: yes}``
+#. With ``document-start: {present: true}``
 
    the following code snippet would **PASS**:
    ::
@@ -45,7 +45,7 @@ Use this rule to require or forbid the use of document start marker (``---``).
     - this
     - is: another one
 
-#. With ``document-start: {present: no}``
+#. With ``document-start: {present: false}``
 
    the following code snippet would **PASS**:
    ::
@@ -72,9 +72,10 @@ from yamllint.linter import LintProblem
 ID = 'document-start'
 TYPE = 'token'
 CONF = {'present': bool}
+DEFAULT = {'present': True}
 
 
-def check(conf, token, prev, next, context):
+def check(conf, token, prev, next, nextnext, context):
     if conf['present']:
         if (isinstance(prev, (yaml.StreamStartToken,
                               yaml.DocumentEndToken,

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 serie
+        # 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

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 Greg Dubicki
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Use this rule to prevent nodes with empty content, that implicitly result in
+``null`` values.
+
+.. rubric:: Options
+
+* Use ``forbid-in-block-mappings`` to prevent empty values in block mappings.
+* Use ``forbid-in-flow-mappings`` to prevent empty values in flow mappings.
+
+.. rubric:: Examples
+
+#. With ``empty-values: {forbid-in-block-mappings: true}``
+
+   the following code snippets would **PASS**:
+   ::
+
+    some-mapping:
+      sub-element: correctly indented
+
+   ::
+
+    explicitly-null: null
+
+   the following code snippets would **FAIL**:
+   ::
+
+    some-mapping:
+    sub-element: incorrectly indented
+
+   ::
+
+    implicitly-null:
+
+#. With ``empty-values: {forbid-in-flow-mappings: true}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    {prop: null}
+    {a: 1, b: 2, c: 3}
+
+   the following code snippets would **FAIL**:
+   ::
+
+    {prop: }
+
+   ::
+
+    {a: 1, b:, c: 3}
+
+"""
+
+import yaml
+
+from yamllint.linter import LintProblem
+
+
+ID = 'empty-values'
+TYPE = 'token'
+CONF = {'forbid-in-block-mappings': bool,
+        'forbid-in-flow-mappings': bool}
+DEFAULT = {'forbid-in-block-mappings': True,
+           'forbid-in-flow-mappings': True}
+
+
+def check(conf, token, prev, next, nextnext, context):
+
+    if conf['forbid-in-block-mappings']:
+        if isinstance(token, yaml.ValueToken) and isinstance(next, (
+                yaml.KeyToken, yaml.BlockEndToken)):
+            yield LintProblem(token.start_mark.line + 1,
+                              token.end_mark.column + 1,
+                              'empty value in block mapping')
+
+    if conf['forbid-in-flow-mappings']:
+        if isinstance(token, yaml.ValueToken) and isinstance(next, (
+                yaml.FlowEntryToken, yaml.FlowMappingEndToken)):
+            yield LintProblem(token.start_mark.line + 1,
+                              token.end_mark.column + 1,
+                              'empty value in flow mapping')

yamllint/rules/hyphens.py

@@ -76,9 +76,10 @@ 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, context):
+def check(conf, token, prev, next, nextnext, context):
     if isinstance(token, yaml.BlockEntryToken):
         problem = spaces_after(token, prev, next,
                                max=conf['max-spaces-after'],

yamllint/rules/indentation.py

@@ -19,14 +19,18 @@ Use this rule to control the indentation.
 
 .. rubric:: Options
 
-* ``spaces`` defines the number of spaces that represent an indentation level.
+* ``spaces`` defines the indentation width, in spaces. Set either to an integer
+  (e.g. ``2`` or ``4``, representing the number of spaces in an indentation
+  level) or to ``consistent`` to allow any number, as long as it remains the
+  same within the file.
 * ``indent-sequences`` defines whether block sequences should be indented or
   not (when in a mapping, this indentation is not mandatory -- some people
-  perceive the ``-`` as part of the indentation). Possible values: ``yes``,
+  perceive the ``-`` as part of the indentation). Possible values: ``true``,
-  ``no`` and ``whatever`` (the latter means either indenting or not indenting
+  ``false``, ``whatever`` and ``consistent``. ``consistent`` requires either
-  block sequences is OK.
+  all block sequences to be indented, or none to be. ``whatever`` means either
+  indenting or not indenting individual block sequences is OK.
 * ``check-multi-line-strings`` defines whether to lint indentation in
-  multi-line strings. Set to ``yes`` to enable, ``no`` to disable.
+  multi-line strings. Set to ``true`` to enable, ``false`` to disable.
 
 .. rubric:: Examples
 
@@ -73,7 +77,29 @@ Use this rule to control the indentation.
         - haystack:
             needle
 
-#. With ``indentation: {spaces: 2, indent-sequences: no}``
+#. With ``indentation: {spaces: consistent}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    history:
+       - name: Unix
+         date: 1969
+       - name: Linux
+         date: 1991
+    nest:
+       recurse:
+          - haystack:
+               needle
+
+   the following code snippet would **FAIL**:
+   ::
+
+    some:
+      Russian:
+          dolls
+
+#. With ``indentation: {spaces: 2, indent-sequences: false}``
 
    the following code snippet would **PASS**:
    ::
@@ -104,7 +130,29 @@ Use this rule to control the indentation.
         - spaghetti
         - sauce
 
-#. With ``indentation: {spaces: 4, check-multi-line-strings: yes}``
+#. With ``indentation: {spaces: 2, indent-sequences: consistent}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    - flying:
+      - spaghetti
+      - monster
+    - not flying:
+      - spaghetti
+      - sauce
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - flying:
+        - spaghetti
+        - monster
+    - not flying:
+      - spaghetti
+      - sauce
+
+#. With ``indentation: {spaces: 4, check-multi-line-strings: true}``
 
    the following code snippet would **PASS**:
    ::
@@ -145,68 +193,85 @@ 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'
 TYPE = 'token'
-CONF = {'spaces': int,
+CONF = {'spaces': (int, 'consistent'),
-        'indent-sequences': (True, False, 'whatever'),
+        'indent-sequences': (bool, 'whatever', 'consistent'),
         'check-multi-line-strings': bool}
+DEFAULT = {'spaces': 'consistent',
+           'indent-sequences': True,
+           'check-multi-line-strings': False}
 
-ROOT, MAP, B_SEQ, F_SEQ, B_ENT, KEY, VAL = range(7)
+ROOT, B_MAP, F_MAP, B_SEQ, F_SEQ, B_ENT, KEY, VAL = range(8)
+labels = ('ROOT', 'B_MAP', 'F_MAP', 'B_SEQ', 'F_SEQ', 'B_ENT', 'KEY', 'VAL')
 
 
 class Parent(object):
-    def __init__(self, type, indent):
+    def __init__(self, type, indent, line_indent=None):
         self.type = type
         self.indent = indent
+        self.line_indent = line_indent
         self.explicit_key = False
+        self.implicit_block_seq = False
+
+    def __repr__(self):
+        return '%s:%d' % (labels[self.type], self.indent)
 
 
 def check_scalar_indentation(conf, token, context):
     if token.start_mark.line == token.end_mark.line:
         return
 
-    if token.plain:
+    def compute_expected_indent(found_indent):
-        expected_indent = token.start_mark.column
+        def detect_indent(base_indent):
-    elif token.style in ('"', "'"):
+            if not isinstance(context['spaces'], int):
-        expected_indent = token.start_mark.column + 1
+                context['spaces'] = found_indent - base_indent
-    elif token.style in ('>', '|'):
+            return base_indent + context['spaces']
-        if context['stack'][-1].type == B_SEQ:
+
-            # - >
+        if token.plain:
-            #     multi
+            return token.start_mark.column
-            #     line
+        elif token.style in ('"', "'"):
-            expected_indent = token.start_mark.column + conf['spaces']
+            return token.start_mark.column + 1
-        elif context['stack'][-1].type == KEY:
+        elif token.style in ('>', '|'):
-            assert context['stack'][-1].explicit_key
+            if context['stack'][-1].type == B_ENT:
-            # - ? >
+                # - >
-            #       multi-line
+                #     multi
-            #       key
+                #     line
-            #   : >
+                return detect_indent(token.start_mark.column)
-            #       multi-line
+            elif context['stack'][-1].type == KEY:
-            #       value
+                assert context['stack'][-1].explicit_key
-            expected_indent = token.start_mark.column + conf['spaces']
+                # - ? >
-        elif context['stack'][-1].type == VAL:
+                #       multi-line
-            if token.start_mark.line + 1 > context['cur_line']:
+                #       key
-                # - key:
-                #     >
-                #       multi
-                #       line
-                expected_indent = context['stack'][-1].indent + conf['spaces']
-            elif context['stack'][-2].explicit_key:
-                # - ? key
                 #   : >
                 #       multi-line
                 #       value
-                expected_indent = token.start_mark.column + conf['spaces']
+                return detect_indent(token.start_mark.column)
+            elif context['stack'][-1].type == VAL:
+                if token.start_mark.line + 1 > context['cur_line']:
+                    # - key:
+                    #     >
+                    #       multi
+                    #       line
+                    return detect_indent(context['stack'][-1].indent)
+                elif context['stack'][-2].explicit_key:
+                    # - ? key
+                    #   : >
+                    #       multi-line
+                    #       value
+                    return detect_indent(token.start_mark.column)
+                else:
+                    # - key: >
+                    #     multi
+                    #     line
+                    return detect_indent(context['stack'][-2].indent)
             else:
-                # - key: >
+                return detect_indent(context['stack'][-1].indent)
-                #     multi
+
-                #     line
+    expected_indent = None
-                expected_indent = context['stack'][-2].indent + conf['spaces']
-        else:
-            expected_indent = context['stack'][-1].indent + conf['spaces']
 
     line_no = token.start_mark.line + 1
 
@@ -224,16 +289,21 @@ def check_scalar_indentation(conf, token, context):
         if token.start_mark.buffer[line_start + indent] == '\n':
             continue
 
+        if expected_indent is None:
+            expected_indent = compute_expected_indent(indent)
+
         if indent != expected_indent:
             yield LintProblem(line_no, indent + 1,
                               'wrong indentation: expected %d but found %d' %
                               (expected_indent, indent))
 
 
-def check(conf, token, prev, next, context):
+def _check(conf, token, prev, next, nextnext, context):
     if 'stack' not in context:
         context['stack'] = [Parent(ROOT, 0)]
         context['cur_line'] = -1
+        context['spaces'] = conf['spaces']
+        context['indent-sequences'] = conf['indent-sequences']
 
     # Step 1: Lint
 
@@ -244,17 +314,22 @@ def check(conf, token, prev, next, context):
     first_in_line = (is_visible and
                      token.start_mark.line + 1 > context['cur_line'])
 
+    def detect_indent(base_indent, next):
+        if not isinstance(context['spaces'], int):
+            context['spaces'] = next.start_mark.column - base_indent
+        return base_indent + context['spaces']
+
     if first_in_line:
         found_indentation = token.start_mark.column
         expected = context['stack'][-1].indent
 
         if isinstance(token, (yaml.FlowMappingEndToken,
                               yaml.FlowSequenceEndToken)):
-            expected = 0
+            expected = context['stack'][-1].line_indent
         elif (context['stack'][-1].type == KEY and
                 context['stack'][-1].explicit_key and
                 not isinstance(token, yaml.ValueToken)):
-            expected += conf['spaces']
+            expected = detect_indent(expected, token)
 
         if found_indentation != expected:
             yield LintProblem(token.start_mark.line + 1, found_indentation + 1,
@@ -275,25 +350,21 @@ def check(conf, token, prev, next, context):
 
     # Step 2.b: Update state
 
-    if context['stack'][-1].type == B_ENT:
-        context['stack'].pop()
-
     if isinstance(token, yaml.BlockMappingStartToken):
+        #   - a: 1
+        # or
+        #   - ? a
+        #     : 1
+        # or
+        #   - ?
+        #       a
+        #     : 1
         assert isinstance(next, yaml.KeyToken)
-        if next.start_mark.line == token.start_mark.line:
+        assert next.start_mark.line == token.start_mark.line
-            #   - a: 1
-            #     b: 2
-            # or
-            #   - ? a
-            #     : 1
-            indent = token.start_mark.column
-        else:
-            #   - ?
-            #       a
-            #     : 1
-            indent = token.start_mark.column + conf['spaces']
 
-        context['stack'].append(Parent(MAP, indent))
+        indent = token.start_mark.column
+
+        context['stack'].append(Parent(B_MAP, indent))
 
     elif isinstance(token, yaml.FlowMappingStartToken):
         if next.start_mark.line == token.start_mark.line:
@@ -301,17 +372,18 @@ def check(conf, token, prev, next, context):
             indent = next.start_mark.column
         else:
             #   - {
-            #   a: 1, b: 2
+            #     a: 1, b: 2
-            # }
+            #   }
-            indent = context['cur_line_indent'] + conf['spaces']
+            indent = detect_indent(context['cur_line_indent'], next)
 
-        context['stack'].append(Parent(MAP, indent))
+        context['stack'].append(Parent(F_MAP, indent,
+                                       line_indent=context['cur_line_indent']))
 
     elif isinstance(token, yaml.BlockSequenceStartToken):
         #   - - a
         #     - b
-        assert next.start_mark.line == token.start_mark.line
         assert isinstance(next, yaml.BlockEntryToken)
+        assert next.start_mark.line == token.start_mark.line
 
         indent = token.start_mark.column
 
@@ -320,17 +392,27 @@ def check(conf, token, prev, next, context):
     elif (isinstance(token, yaml.BlockEntryToken) and
             # in case of an empty entry
             not isinstance(next, (yaml.BlockEntryToken, yaml.BlockEndToken))):
+        # It looks like pyyaml doesn't issue BlockSequenceStartTokens when the
+        # list is not indented. We need to compensate that.
+        if context['stack'][-1].type != B_SEQ:
+            context['stack'].append(Parent(B_SEQ, token.start_mark.column))
+            context['stack'][-1].implicit_block_seq = True
+
         if next.start_mark.line == token.end_mark.line:
             #   - item 1
             #   - item 2
             indent = next.start_mark.column
+        elif next.start_mark.column == token.start_mark.column:
+            #   -
+            #   key: value
+            indent = next.start_mark.column
         else:
             #   -
             #     item 1
             #   -
             #     key:
             #       value
-            indent = token.start_mark.column + conf['spaces']
+            indent = detect_indent(token.start_mark.column, next)
 
         context['stack'].append(Parent(B_ENT, indent))
 
@@ -342,15 +424,10 @@ def check(conf, token, prev, next, context):
             #   - [
             #   a, b
             # ]
-            indent = context['cur_line_indent'] + conf['spaces']
+            indent = detect_indent(context['cur_line_indent'], next)
 
-        context['stack'].append(Parent(F_SEQ, indent))
+        context['stack'].append(Parent(F_SEQ, indent,
-
+                                       line_indent=context['cur_line_indent']))
-    elif isinstance(token, (yaml.BlockEndToken,
-                            yaml.FlowMappingEndToken,
-                            yaml.FlowSequenceEndToken)):
-        assert context['stack'][-1].type in (MAP, B_SEQ, F_SEQ)
-        context['stack'].pop()
 
     elif isinstance(token, yaml.KeyToken):
         indent = context['stack'][-1].indent
@@ -359,21 +436,25 @@ def check(conf, token, prev, next, context):
 
         context['stack'][-1].explicit_key = is_explicit_key(token)
 
-    if context['stack'][-1].type == VAL:
-        context['stack'].pop()
-        assert context['stack'][-1].type == KEY
-        context['stack'].pop()
-
     elif isinstance(token, yaml.ValueToken):
         assert context['stack'][-1].type == KEY
 
-        # Discard empty values
+        # Special cases:
-        if isinstance(next, (yaml.BlockEndToken,
+        #     key: &anchor
-                             yaml.FlowMappingEndToken,
+        #       value
-                             yaml.FlowSequenceEndToken,
+        # and:
-                             yaml.KeyToken)):
+        #     key: !!tag
-            context['stack'].pop()
+        #       value
-        else:
+        if isinstance(next, (yaml.AnchorToken, yaml.TagToken)):
+            if (next.start_mark.line == prev.start_mark.line and
+                    next.start_mark.line < nextnext.start_mark.line):
+                next = nextnext
+
+        # Only if value is not empty
+        if not isinstance(next, (yaml.BlockEndToken,
+                                 yaml.FlowMappingEndToken,
+                                 yaml.FlowSequenceEndToken,
+                                 yaml.KeyToken)):
             if context['stack'][-1].explicit_key:
                 #   ? k
                 #   : value
@@ -381,7 +462,7 @@ def check(conf, token, prev, next, context):
                 #   ? k
                 #   :
                 #     value
-                indent = context['stack'][-1].indent + conf['spaces']
+                indent = detect_indent(context['stack'][-1].indent, next)
             elif next.start_mark.line == prev.start_mark.line:
                 #   k: value
                 indent = next.start_mark.column
@@ -392,33 +473,103 @@ def check(conf, token, prev, next, context):
                 # yaml.scan()ning this:
                 #     '- lib:\n'
                 #     '  - var\n'
-                if conf['indent-sequences'] is False:
+                if context['indent-sequences'] is False:
                     indent = context['stack'][-1].indent
-                elif conf['indent-sequences'] is True:
+                elif context['indent-sequences'] is True:
-                    indent = context['stack'][-1].indent + conf['spaces']
+                    if (context['spaces'] == 'consistent' and
-                else:  # 'whatever'
+                            next.start_mark.column -
+                            context['stack'][-1].indent == 0):
+                        # In this case, the block sequence item is not indented
+                        # (while it should be), but we don't know yet the
+                        # indentation it should have (because `spaces` is
+                        # `consistent` and its value has not been computed yet
+                        # -- this is probably the beginning of the document).
+                        # So we choose an arbitrary value (2).
+                        indent = 2
+                    else:
+                        indent = detect_indent(context['stack'][-1].indent,
+                                               next)
+                else:  # 'whatever' or 'consistent'
                     if next.start_mark.column == context['stack'][-1].indent:
                         #   key:
                         #   - e1
                         #   - e2
+                        if context['indent-sequences'] == 'consistent':
+                            context['indent-sequences'] = False
                         indent = context['stack'][-1].indent
                     else:
+                        if context['indent-sequences'] == 'consistent':
+                            context['indent-sequences'] = True
                         #   key:
                         #     - e1
                         #     - e2
-                        indent = context['stack'][-1].indent + conf['spaces']
+                        indent = detect_indent(context['stack'][-1].indent,
+                                               next)
             else:
                 #   k:
                 #     value
-                indent = context['stack'][-1].indent + conf['spaces']
+                indent = detect_indent(context['stack'][-1].indent, next)
 
             context['stack'].append(Parent(VAL, indent))
 
-    if (context['stack'][-1].type == KEY and
+    consumed_current_token = False
-            isinstance(next, (yaml.BlockEndToken,
+    while True:
-                              yaml.FlowMappingEndToken,
+        if (context['stack'][-1].type == F_SEQ and
-                              yaml.FlowSequenceEndToken,
+                isinstance(token, yaml.FlowSequenceEndToken) and
-                              yaml.KeyToken))):
+                not consumed_current_token):
-        # A key without a value: it's part of a set. Let's drop this key
+            context['stack'].pop()
-        # and leave room for the next one.
+            consumed_current_token = True
-        context['stack'].pop()
+
+        elif (context['stack'][-1].type == F_MAP and
+                isinstance(token, yaml.FlowMappingEndToken) and
+                not consumed_current_token):
+            context['stack'].pop()
+            consumed_current_token = True
+
+        elif (context['stack'][-1].type in (B_MAP, B_SEQ) and
+                isinstance(token, yaml.BlockEndToken) and
+                not context['stack'][-1].implicit_block_seq and
+                not consumed_current_token):
+            context['stack'].pop()
+            consumed_current_token = True
+
+        elif (context['stack'][-1].type == B_ENT and
+                not isinstance(token, yaml.BlockEntryToken) and
+                context['stack'][-2].implicit_block_seq and
+                not isinstance(token, (yaml.AnchorToken, yaml.TagToken)) and
+                not isinstance(next, yaml.BlockEntryToken)):
+            context['stack'].pop()
+            context['stack'].pop()
+
+        elif (context['stack'][-1].type == B_ENT and
+                isinstance(next, (yaml.BlockEntryToken, yaml.BlockEndToken))):
+            context['stack'].pop()
+
+        elif (context['stack'][-1].type == VAL and
+                not isinstance(token, yaml.ValueToken) and
+                not isinstance(token, (yaml.AnchorToken, yaml.TagToken))):
+            assert context['stack'][-2].type == KEY
+            context['stack'].pop()
+            context['stack'].pop()
+
+        elif (context['stack'][-1].type == KEY and
+                isinstance(next, (yaml.BlockEndToken,
+                                  yaml.FlowMappingEndToken,
+                                  yaml.FlowSequenceEndToken,
+                                  yaml.KeyToken))):
+            # A key without a value: it's part of a set. Let's drop this key
+            # and leave room for the next one.
+            context['stack'].pop()
+
+        else:
+            break
+
+
+def check(conf, token, prev, next, nextnext, context):
+    try:
+        for problem in _check(conf, token, prev, next, nextnext, context):
+            yield problem
+    except AssertionError:
+        yield LintProblem(token.start_mark.line + 1,
+                          token.start_mark.column + 1,
+                          'cannot infer indentation: unexpected token')

yamllint/rules/key_duplicates.py

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

yamllint/rules/key_ordering.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 Johannes F. Knauf
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Use this rule to enforce alphabetical ordering of keys in mappings. The sorting
+order uses the Unicode code point number. As a result, the ordering is
+case-sensitive and not accent-friendly (see examples below).
+
+.. rubric:: Examples
+
+#. With ``key-ordering: {}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    - key 1: v
+      key 2: val
+      key 3: value
+    - {a: 1, b: 2, c: 3}
+    - T-shirt: 1
+      T-shirts: 2
+      t-shirt: 3
+      t-shirts: 4
+    - hair: true
+      hais: true
+      haïr: true
+      haïssable: true
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - key 2: v
+      key 1: val
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - {b: 1, a: 2}
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - T-shirt: 1
+      t-shirt: 2
+      T-shirts: 3
+      t-shirts: 4
+
+   the following code snippet would **FAIL**:
+   ::
+
+    - haïr: true
+      hais: true
+"""
+
+import yaml
+
+from yamllint.linter import LintProblem
+
+
+ID = 'key-ordering'
+TYPE = 'token'
+
+MAP, SEQ = range(2)
+
+
+class Parent(object):
+    def __init__(self, type):
+        self.type = type
+        self.keys = []
+
+
+def check(conf, token, prev, next, nextnext, context):
+    if 'stack' not in context:
+        context['stack'] = []
+
+    if isinstance(token, (yaml.BlockMappingStartToken,
+                          yaml.FlowMappingStartToken)):
+        context['stack'].append(Parent(MAP))
+    elif isinstance(token, (yaml.BlockSequenceStartToken,
+                            yaml.FlowSequenceStartToken)):
+        context['stack'].append(Parent(SEQ))
+    elif isinstance(token, (yaml.BlockEndToken,
+                            yaml.FlowMappingEndToken,
+                            yaml.FlowSequenceEndToken)):
+        context['stack'].pop()
+    elif (isinstance(token, yaml.KeyToken) and
+          isinstance(next, yaml.ScalarToken)):
+        # This check is done because KeyTokens can be found inside flow
+        # sequences... strange, but allowed.
+        if len(context['stack']) > 0 and context['stack'][-1].type == MAP:
+            if any(next.value < key for key in context['stack'][-1].keys):
+                yield LintProblem(
+                    next.start_mark.line + 1, next.start_mark.column + 1,
+                    'wrong ordering of key "%s" in mapping' % next.value)
+            else:
+                context['stack'][-1].keys.append(next.value)

yamllint/rules/line_length.py

@@ -17,12 +17,18 @@
 """
 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.
 * ``allow-non-breakable-words`` is used to allow non breakable words (without
   spaces inside) to overflow the limit. This is useful for long URLs, for
-  instance. Use ``yes`` to allow, ``no`` to forbid.
+  instance. Use ``true`` to allow, ``false`` to forbid.
+* ``allow-non-breakable-inline-mappings`` implies ``allow-non-breakable-words``
+  and extends it to also allow non-breakable words in inline mappings.
 
 .. rubric:: Examples
 
@@ -42,7 +48,7 @@ Use this rule to set a limit to lines length.
       Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod
       tempor incididunt ut labore et dolore magna aliqua.
 
-#. With ``line-length: {max: 60, allow-non-breakable-words: yes}``
+#. With ``line-length: {max: 60, allow-non-breakable-words: true}``
 
    the following code snippet would **PASS**:
    ::
@@ -59,9 +65,22 @@ Use this rule to set a limit to lines length.
    the following code snippet would **FAIL**:
    ::
 
-    - this line is waaaaaaaaaaaaaay too long but could be easily splitted...
+    - this line is waaaaaaaaaaaaaay too long but could be easily split...
 
-#. With ``line-length: {max: 60, allow-non-breakable-words: no}``
+   and the following code snippet would also **FAIL**:
+   ::
+
+    - foobar: http://localhost/very/very/very/very/very/very/very/very/long/url
+
+#. With ``line-length: {max: 60, allow-non-breakable-words: true,
+   allow-non-breakable-inline-mappings: true}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    - foobar: http://localhost/very/very/very/very/very/very/very/very/long/url
+
+#. With ``line-length: {max: 60, allow-non-breakable-words: false}``
 
    the following code snippet would **FAIL**:
    ::
@@ -73,29 +92,58 @@ Use this rule to set a limit to lines length.
 """
 
 
+import yaml
+
 from yamllint.linter import LintProblem
 
 
 ID = 'line-length'
 TYPE = 'line'
 CONF = {'max': int,
-        'allow-non-breakable-words': bool}
+        '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):
+    loader = yaml.SafeLoader(line.content)
+    try:
+        while loader.peek_token():
+            if isinstance(loader.get_token(), yaml.BlockMappingStartToken):
+                while loader.peek_token():
+                    if isinstance(loader.get_token(), yaml.ValueToken):
+                        t = loader.get_token()
+                        if isinstance(t, yaml.ScalarToken):
+                            return (
+                                ' ' not in line.content[t.start_mark.column:])
+    except yaml.scanner.ScannerError:
+        pass
+
+    return False
 
 
 def check(conf, line):
     if line.end - line.start > conf['max']:
+        conf['allow-non-breakable-words'] |= \
+            conf['allow-non-breakable-inline-mappings']
         if conf['allow-non-breakable-words']:
             start = line.start
             while start < line.end and line.buffer[start] == ' ':
                 start += 1
 
             if start != line.end:
-                if line.buffer[start] == '#':
+                if line.buffer[start] in ('#', '-'):
                     start += 2
 
                 if line.buffer.find(' ', start, line.end) == -1:
                     return
 
+                if (conf['allow-non-breakable-inline-mappings'] and
+                        check_inline_mapping(line)):
+                    return
+
         yield LintProblem(line.line_no, conf['max'] + 1,
                           'line too long (%d > %d characters)' %
                           (line.end - line.start, conf['max']))

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

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2017 ScienJus
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Use this rule to prevent values with octal numbers. In YAML, numbers that
+start with ``0`` are interpreted as octal, but this is not always wanted.
+For instance ``010`` is the city code of Beijing, and should not be
+converted to ``8``.
+
+.. rubric:: Examples
+
+#. With ``octal-values: {forbid-implicit-octal: true}``
+
+   the following code snippets would **PASS**:
+   ::
+
+    user:
+      city-code: '010'
+
+   the following code snippets would **PASS**:
+   ::
+
+    user:
+      city-code: 010,021
+
+   the following code snippets would **FAIL**:
+   ::
+
+    user:
+      city-code: 010
+
+#. With ``octal-values: {forbid-explicit-octal: true}``
+
+   the following code snippets would **PASS**:
+   ::
+
+    user:
+      city-code: '0o10'
+
+   the following code snippets would **FAIL**:
+   ::
+
+    user:
+      city-code: 0o10
+"""
+
+import yaml
+
+from yamllint.linter import LintProblem
+
+
+ID = 'octal-values'
+TYPE = 'token'
+CONF = {'forbid-implicit-octal': bool,
+        'forbid-explicit-octal': bool}
+DEFAULT = {'forbid-implicit-octal': True,
+           'forbid-explicit-octal': True}
+
+
+def check(conf, token, prev, next, nextnext, context):
+    if prev and isinstance(prev, yaml.tokens.TagToken):
+        return
+
+    if conf['forbid-implicit-octal']:
+        if isinstance(token, yaml.tokens.ScalarToken):
+            if not token.style:
+                val = token.value
+                if val.isdigit() and len(val) > 1 and val[0] == '0':
+                    yield LintProblem(
+                        token.start_mark.line + 1, token.end_mark.column + 1,
+                        'forbidden implicit octal value "%s"' %
+                        token.value)
+
+    if conf['forbid-explicit-octal']:
+        if isinstance(token, yaml.tokens.ScalarToken):
+            if not token.style:
+                val = token.value
+                if len(val) > 2 and val[:2] == '0o' and val[2:].isdigit():
+                    yield LintProblem(
+                        token.start_mark.line + 1, token.end_mark.column + 1,
+                        'forbidden explicit octal value "%s"' %
+                        token.value)

yamllint/rules/quoted_strings.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018 ClearScore
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Use this rule to forbid any string values that are not quoted, or to prevent
+quoted strings without needing it. You can also enforce the type of the quote
+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, required: true}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    foo: "bar"
+    bar: 'foo'
+    number: 123
+    boolean: true
+
+   the following code snippet would **FAIL**:
+   ::
+
+    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
+
+from yamllint.linter import LintProblem
+
+ID = 'quoted-strings'
+TYPE = 'token'
+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'
+
+
+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 _quotes_are_needed(string):
+    loader = yaml.BaseLoader('key: ' + string)
+    # Remove the 5 first tokens corresponding to 'key: ' (StreamStartToken,
+    # BlockMappingStartToken, KeyToken, ScalarToken(value=key), ValueToken)
+    for _ in range(5):
+        loader.get_token()
+    try:
+        a, b = loader.get_token(), loader.get_token()
+        if (isinstance(a, yaml.ScalarToken) and a.style is None and
+                isinstance(b, yaml.BlockEndToken)):
+            return False
+        return True
+    except yaml.scanner.ScannerError:
+        return True
+
+
+def check(conf, token, prev, next, nextnext, context):
+    if not (isinstance(token, yaml.tokens.ScalarToken) and
+            isinstance(prev, (yaml.BlockEntryToken, yaml.FlowEntryToken,
+                              yaml.FlowSequenceStartToken, yaml.TagToken,
+                              yaml.ValueToken))):
+
+        return
+
+    # Ignore explicit types, e.g. !!str testtest or !!int 42
+    if (prev and isinstance(prev, yaml.tokens.TagToken) and
+            prev.value[0] == '!!'):
+        return
+
+    # Ignore numbers, booleans, etc.
+    resolver = yaml.resolver.Resolver()
+    tag = resolver.resolve(yaml.nodes.ScalarNode, token.value, (True, False))
+    if token.plain and tag != DEFAULT_SCALAR_TAG:
+        return
+
+    # Ignore multi-line strings
+    if (not token.plain) and (token.style == "|" or token.style == ">"):
+        return
+
+    quote_type = conf['quote-type']
+    required = conf['required']
+
+    # 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
+                not _quotes_are_needed(token.value)):
+            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

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2016 Peter Ericson
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Use this rule to forbid non-explictly typed truthy values other than allowed
+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'``.
+* ``check-keys`` disables verification for keys in mappings. By default,
+  ``truthy`` rule applies to both keys and values. Set this option to ``false``
+  to prevent this.
+
+.. rubric:: Examples
+
+#. With ``truthy: {}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    boolean: true
+
+    object: {"True": 1, 1: "True"}
+
+    "yes":  1
+    "on":   2
+    "True": 3
+
+     explicit:
+       string1: !!str True
+       string2: !!str yes
+       string3: !!str off
+       encoded: !!binary |
+                  True
+                  OFF
+                  pad==  # this decodes as 'N\xbb\x9e8Qii'
+       boolean1: !!bool true
+       boolean2: !!bool "false"
+       boolean3: !!bool FALSE
+       boolean4: !!bool True
+       boolean5: !!bool off
+       boolean6: !!bool NO
+
+   the following code snippet would **FAIL**:
+   ::
+
+    object: {True: 1, 1: True}
+
+   the following code snippet would **FAIL**:
+   ::
+
+    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
+
+#. With ``truthy: {check-keys: false}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    yes:  1
+    on:   2
+    true: 3
+
+   the following code snippet would **FAIL**:
+   ::
+
+    yes:  Yes
+    on:   On
+    true: True
+"""
+
+import yaml
+
+from yamllint.linter import LintProblem
+
+
+TRUTHY = ['YES', 'Yes', 'yes',
+          'NO', 'No', 'no',
+          'TRUE', 'True', 'true',
+          'FALSE', 'False', 'false',
+          'ON', 'On', 'on',
+          'OFF', 'Off', 'off']
+
+
+ID = 'truthy'
+TYPE = 'token'
+CONF = {'allowed-values': list(TRUTHY), 'check-keys': bool}
+DEFAULT = {'allowed-values': ['true', 'false'], 'check-keys': True}
+
+
+def check(conf, token, prev, next, nextnext, context):
+    if prev and isinstance(prev, yaml.tokens.TagToken):
+        return
+
+    if (not conf['check-keys'] and isinstance(prev, yaml.tokens.KeyToken) and
+            isinstance(token, yaml.tokens.ScalarToken)):
+        return
+
+    if isinstance(token, yaml.tokens.ScalarToken):
+        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 one of [" +
+                              ", ".join(sorted(conf['allowed-values'])) + "]")