Prototype: yaml-fix-indentation

.flake8

@@ -1,4 +0,0 @@
-[flake8]
-import-order-style = pep8
-application-import-names = yamllint
-ignore = W503,W504

.github/workflows/ci.yaml

@@ -1,61 +0,0 @@
----
-
-name: CI
-
-on:  # yamllint disable-line rule:truthy
-  push:
-  pull_request:
-    branches:
-      - master
-
-permissions:
-  contents: read
-
-jobs:
-  lint:
-    name: Linters
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Set up Python
-        uses: actions/setup-python@v4
-      - run:
-          pip install flake8 flake8-import-order sphinx rstcheck[sphinx] doc8
-      - run: pip install .
-      - run: flake8 .
-      - run: doc8 $(git ls-files '*.rst')
-      - run: rstcheck --ignore-directives automodule $(git ls-files '*.rst')
-      - run: yamllint --strict $(git ls-files '*.yaml' '*.yml')
-      - run: make -C docs html
-      - name: Check for broken links in documentation
-        run: make -C docs linkcheck
-
-  test:
-    name: Tests
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version:
-          - '3.7'
-          - '3.8'
-          - '3.9'
-          - '3.10'
-          - '3.11'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-      - name: Append GitHub Actions system path
-        run: echo "$HOME/.local/bin" >> $GITHUB_PATH
-      - run: pip install coverage
-      - run: pip install .
-      # https://github.com/AndreMiras/coveralls-python-action/issues/18
-      - run: echo -e "[run]\nrelative_files = True" > .coveragerc
-      - run: coverage run -m unittest discover
-      - name: Coveralls
-        uses: AndreMiras/coveralls-python-action@develop

.gitignore

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

.pre-commit-hooks.yaml

@@ -1,11 +0,0 @@
----
-
-# 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

@@ -0,0 +1,17 @@
+---
+language: python
+python:
+  - 2.7
+  - 3.3
+  - 3.4
+  - 3.5
+  - nightly
+install:
+  - pip install pyyaml flake8 coveralls
+  - pip install .
+script:
+  - flake8 .
+  - yamllint $(git ls-files '*.yaml' '*.yml')
+  - coverage run --source=yamllint setup.py test
+after_success:
+  coveralls

CHANGELOG.rst

@@ -1,279 +0,0 @@
-Changelog
-=========
-
-1.32.0 (2023-05-22)
--------------------
-
-- Look for configuration file in parent directories
-- Rule ``anchors``: add new option ``forbid-unused-anchors``
-
-1.31.0 (2023-04-21)
--------------------
-
-- Build: migrate from ``setup.py`` to ``pyproject.toml``
-- Docs: update some outdated URLs
-- Rule ``colons``: prevent error when space before is mandatory
-
-1.30.0 (2023-03-22)
--------------------
-
-- Rule ``anchors``: add new rule to detect undeclared or duplicated anchors
-- Python API: prevent using ``is_file_ignored()`` with null ``filepath``
-- Docs: fix misleading Python API example
-- Docs: fix plain text code snippet example
-- Docs: update pre-commit hook example
-
-1.29.0 (2023-01-10)
--------------------
-
-- Add support for Python 3.11, drop support for Python 3.6
-- Rule ``float-values``: fix bug on strings containing fordidden values
-- Stop releasing universal wheels
-- Use proper Python 3 I/O type for file reading
-- Rule ``indentation``: fix ``indent-sequences`` in nested collections
-- Docs: clarify ``disable-line`` and parser errors, give a workaround
-- Refactors to apply some pyupgrade suggestions
-- Allow using a list of strings in ``ignore`` configuration
-- Add ``--list-files`` command line option
-
-1.28.0 (2022-09-12)
--------------------
-
-- Better compress PNG image in documentation
-- Remove ``__future__`` imports specific to Python 2
-- Remove inheritance from ``object`` specific to Python 2
-- Simplify GitHub Actions example in documentation
-- Update ALE vim plugin link in documentation
-- Update license to latest version of GPLv3
-- Pre-compile disable/enable rules regexes
-- Rule ``quoted-strings``: add ``allow-quoted-quotes`` option
-- Add option ``ignore-from-file`` in config
-
-1.27.1 (2022-07-08)
--------------------
-
-- Fix failing test on ``key-duplicates`` for old PyYAML versions
-
-1.27.0 (2022-07-08)
--------------------
-
-- Add support for Python 3.10, drop Python 3.5
-- Fix GitHub Actions workflow
-- Refactor ``--format=auto`` logic
-- Update GitHub format output to use groups
-- Rule ``comments``: allow whitespace after the shebang marker
-- Multiple minor fixes in documentation
-- Configure Sphinx to make man page show up in apropos
-- Attempt to clarify configuration file location in documentation
-- Rule ``key-duplicates``: don't crash on redundant closing brackets or braces
-- Use ``rstcheck`` to lint documentation on the CI
-- Remove UTF-8 headers in Python files, since Python 2 isn't supported
-- Add various tests to increase coverage
-- Rule ``octal-values``: pre-compile regex for performance
-- Add sections for Visual Studio Code and IntelliJ in documentation
-- Rule ``new-lines``: add the ``type: platform`` config option
-- Add the new rule ``float-values``
-
-1.26.3 (2021-08-21)
--------------------
-
-- Restore runtime dependency ``setuptools`` for Python < 3.8
-
-1.26.2 (2021-08-03)
--------------------
-
-- Fix ``python_requires`` to comply with PEP 345 and PEP 440
-
-1.26.1 (2021-04-06)
--------------------
-
-- Remove runtime dependency ``setuptools`` for Python < 3.8
-- Fix ``line_length`` to skip all hash signs starting comment
-
-1.26.0 (2021-01-29)
--------------------
-
-- End support for Python 2 and Python 3.4, add support for Python 3.9
-- Add ``forbid: non-empty`` option to ``braces`` and ``brackets`` rules
-- Fix ``quoted-strings`` for explicit octal recognition
-- Add documentation for integration with Arcanist
-- Fix typos in changelog and README
-- Stop using deprecated ``python setup.py test`` in tests
-
-1.25.0 (2020-09-29)
--------------------
-
-- Run tests on Travis both with and without UTF-8 locales
-- Improve documentation with default values to rules with options
-- Improve documentation with a Python API usage example
-- Fix documentation on ``commas`` examples
-- Packaging: move setuptools' configuration from ``setup.py`` to ``setup.cfg``
-- Packaging: add extra info in PyPI metadata
-- Improve documentation on ``yaml-files``
-- Fix ``octal-values`` to prevent detection of ``8`` and ``9`` as octal values
-- Fix ``quoted-strings`` Fix detecting strings with hashtag as requiring quotes
-- Add ``forbid`` configuration to the ``braces`` and ``brackets`` rules
-- Fix runtime dependencies missing ``setuptools``
-- Add a new output format for GitHub Annotations (``--format github``)
-- Fix DOS lines messing with rule IDs in directives
-
-1.24.2 (2020-07-16)
--------------------
-
-- Add ``locale`` config option and make ``key-ordering`` locale-aware
-
-1.24.1 (2020-07-15)
--------------------
-
-- Revert ``locale`` config option from version 1.24.0 because of a bug
-
-1.24.0 (2020-07-15)
--------------------
-
-- Specify config with environment variable ``YAMLLINT_CONFIG_FILE``
-- Fix bug with CRLF in ``new-lines`` and ``require-starting-space``
-- Do not run linter on directories whose names look like YAML files
-- Add ``locale`` config option and make ``key-ordering`` locale-aware
-
-1.23.0 (2020-04-17)
--------------------
-
-- Allow rules to validate their configuration
-- Add options ``extra-required`` and ``extra-allowed`` to ``quoted-strings``
-
-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

CONTRIBUTING.rst

@@ -1,48 +0,0 @@
-Contributing
-============
-
-Pull requests are the best way to propose changes to the codebase.
-Contributions are welcome, but they have to meet some criteria.
-
-Pull Request Process
---------------------
-
-1. Fork this Git repository and create your branch from ``master``.
-
-2. Make sure the tests pass:
-
-   .. code:: bash
-
-    pip install --user .
-    python -m unittest discover  # all tests...
-    python -m unittest tests/rules/test_commas.py  # or just some tests (faster)
-
-3. If you add code that should be tested, add tests.
-
-4. Make sure the linters pass:
-
-   .. code:: bash
-
-    flake8 .
-
-   If you added/modified documentation:
-
-   .. code:: bash
-
-    doc8 $(git ls-files '*.rst')
-
-   If you touched YAML files:
-
-   .. code:: bash
-
-    yamllint --strict $(git ls-files '*.yaml' '*.yml')
-
-5. If relevant, update documentation (either in ``docs`` directly or in rules
-   files themselves).
-
-6. Write a `good commit message
-   <http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html>`_.
-   If the pull request has multiple commits, each must be atomic (single
-   irreducible change that makes sense on its own).
-
-7. Then, open a pull request.

LICENSE

@@ -1,7 +1,7 @@
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -645,7 +645,7 @@ the "copyright" line and a pointer to where the full notice is found.
     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 <https://www.gnu.org/licenses/>.
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 
@@ -664,11 +664,11 @@ might be different; for a GUI interface, you would use an "about box".
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
 For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
+<http://www.gnu.org/licenses/>.
 
   The GNU General Public License does not permit incorporating your program
 into proprietary programs.  If your program is a subroutine library, you
 may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

MANIFEST.in

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

README.rst

@@ -8,26 +8,26 @@ repetition and cosmetic problems such as lines length, trailing spaces,
 indentation, etc.
 
 .. image::
-   https://github.com/adrienverge/yamllint/actions/workflows/ci.yaml/badge.svg?branch=master
+   https://travis-ci.org/adrienverge/yamllint.svg?branch=master
-   :target: https://github.com/adrienverge/yamllint/actions/workflows/ci.yaml?query=branch%3Amaster
+   :target: https://travis-ci.org/adrienverge/yamllint
    :alt: CI tests status
 .. image::
    https://coveralls.io/repos/github/adrienverge/yamllint/badge.svg?branch=master
    :target: https://coveralls.io/github/adrienverge/yamllint?branch=master
    :alt: Code coverage status
 .. image:: https://readthedocs.org/projects/yamllint/badge/?version=latest
-   :target: https://yamllint.readthedocs.io/en/latest/?badge=latest
+   :target: http://yamllint.readthedocs.org/en/latest/?badge=latest
    :alt: Documentation status
 
-Written in Python (compatible with Python 3 only).
+Written in Python (compatible with Python 2 & 3).
 
 Documentation
 -------------
 
-https://yamllint.readthedocs.io/
+http://yamllint.readthedocs.org/
 
-Overview
+Short overview
---------
+--------------
 
 Screenshot
 ^^^^^^^^^^
@@ -38,15 +38,30 @@ Screenshot
 Installation
 ^^^^^^^^^^^^
 
-Using pip, the Python package manager:
+On Fedora / CentOS:
 
 .. code:: bash
 
- pip install --user yamllint
+ sudo dnf install yamllint
 
-yamllint is also packaged for all major operating systems, see installation
+On Debian 9+ / Ubuntu 16.04+:
-examples (``dnf``, ``apt-get``...) `in the documentation
+
-<https://yamllint.readthedocs.io/en/stable/quickstart.html>`_.
+.. code:: bash
+
+ sudo apt-get install yamllint
+
+On older Debian / Ubuntu versions:
+
+.. code:: bash
+
+ sudo add-apt-repository -y ppa:adrienverge/ppa && sudo apt-get update
+ sudo apt-get install yamllint
+
+Alternatively using pip, the Python package manager:
+
+.. code:: bash
+
+ sudo pip install yamllint
 
 Usage
 ^^^^^
@@ -67,19 +82,15 @@ Usage
  yamllint -d relaxed file.yaml
 
  # Use a custom lint configuration
- yamllint -c /path/to/myconfig file-to-lint.yaml
+ yamllint -c ~/myconfig file.yml
 
 .. code:: bash
 
  # Output a parsable format (for syntax checking in editors like Vim, emacs...)
  yamllint -f parsable file.yaml
 
-`Read more in the complete documentation! <https://yamllint.readthedocs.io/>`__
+Configuration example
-
+^^^^^^^^^^^^^^^^^^^^^
-Features
-^^^^^^^^
-
-Here is a yamllint configuration file example:
 
 .. code:: yaml
 
@@ -93,48 +104,3 @@ Here is a yamllint configuration file example:
 
    # don't bother me with this rule
    indentation: disable
-
-Within a YAML file, special comments can be used to disable checks for a single
-line:
-
-.. code:: yaml
-
- This line is waaaaaaaaaay too long  # yamllint disable-line
-
-or for a whole block:
-
-.. code:: yaml
-
- # yamllint disable rule:colons
- - Lorem       : ipsum
-   dolor       : sit amet,
-   consectetur : adipiscing elit
- # yamllint enable
-
-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/Makefile

@@ -2,7 +2,7 @@
 #
 
 # You can set these variables from the command line.
-SPHINXOPTS    = -W
+SPHINXOPTS    =
 SPHINXBUILD   = sphinx-build
 PAPER         =
 BUILDDIR      = _build

docs/conf.py

@@ -1,13 +1,13 @@
+# -*- coding: utf-8 -*-
 # yamllint documentation build configuration file, created by
 # sphinx-quickstart on Thu Jan 21 21:18:52 2016.
 
 import sys
 import os
-from unittest.mock import MagicMock
 
-sys.path.insert(0, os.path.abspath('..'))
+sys.path.insert(0, os.path.abspath('..'))  # noqa
 
-from yamllint import __copyright__, APP_NAME, APP_VERSION  # noqa
+from yamllint import __copyright__, APP_NAME, APP_VERSION
 
 # -- General configuration ------------------------------------------------
 
@@ -20,7 +20,7 @@ source_suffix = '.rst'
 master_doc = 'index'
 
 project = APP_NAME
-copyright = __copyright__.lstrip('Copyright ')
+copyright = __copyright__
 
 version = APP_VERSION
 release = APP_VERSION
@@ -38,17 +38,5 @@ htmlhelp_basename = 'yamllintdoc'
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'yamllint', 'Linter for YAML files', ['Adrien Vergé'], 1)
+    ('index', 'yamllint', '', [u'Adrien Vergé'], 1)
 ]
-
-# -- Build with sphinx automodule without needing to install third-party libs
-
-
-class Mock(MagicMock):
-    @classmethod
-    def __getattr__(cls, name):
-        return MagicMock()
-
-
-MOCK_MODULES = ['pathspec', 'yaml']
-sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)

docs/configuration.rst

@@ -1,27 +1,16 @@
 Configuration
 =============
 
-yamllint uses a set of :doc:`rules <rules>` to check source files for problems.
+yamllint uses a set of *rules* to check sources files for problems. Each rule is
-Each rule is independent from the others, and can be enabled, disabled or
+independent from the others, and can be enabled, disabled or tweaked. All these
-tweaked. All these settings can be gathered in a configuration file.
+settings can be gathered in a configuration file.
 
-To use a custom configuration file, use the ``-c`` option:
+To use a custom configuration file, either name it ``.yamllint`` in your working
+directory, or use the ``-c`` option:
 
 .. code:: bash
 
- yamllint -c /path/to/myconfig file-to-lint.yaml
+ yamllint -c ~/myconfig file.yaml
-
-If ``-c`` is not provided, yamllint will look for a configuration file in the
-following locations (by order of preference):
-
-- a file named ``.yamllint``, ``.yamllint.yaml``, or ``.yamllint.yml`` in the
-  current working directory, or a parent directory (the search for this file is
-  terminated at the user's home or filesystem root)
-- a filename referenced by ``$YAMLLINT_CONFIG_FILE``, if set
-- a file named ``$XDG_CONFIG_HOME/yamllint/config`` or
-  ``~/.config/yamllint/config``, if present
-
-Finally if no config file is found, the default configuration is applied.
 
 Default configuration
 ---------------------
@@ -34,10 +23,7 @@ Unless told otherwise, yamllint uses its ``default`` configuration:
 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:
+suggests, it is more tolerant.
-
-.. literalinclude:: ../yamllint/conf/relaxed.yaml
-   :language: yaml
 
 It can be chosen using:
 
@@ -48,9 +34,9 @@ It can be chosen using:
 Extending the default configuration
 -----------------------------------
 
-When writing a custom configuration file, you don't need to redefine every
+When writing a custom configuration file, you don't need to redefine every rule.
-rule. Just extend the ``default`` configuration (or any already-existing
+Just extend the ``default`` configuration (or any already-existing configuration
-configuration file).
+file).
 
 For instance, if you just want to disable the ``comments-indentation`` rule,
 your file could look like this:
@@ -105,151 +91,8 @@ 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).
-
-By default the script will exit with a return code ``1`` *only when* there is
-one or more error(s).
-
-However if strict mode is enabled with the ``-s`` (or ``--strict``) option, the
-return code will be:
-
- * ``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 when listing
-directories, 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).
-
-If you need to know the exact list of files that yamllint would process,
-without really linting them, you can use ``--list-files``:
-
-.. code:: bash
-
- yamllint --list-files .
-
-Ignoring paths
---------------
-
-It is possible to exclude specific files or directories, so that the linter
-doesn't process them. They can be provided either as a list of paths, or as a
-bulk string.
-
-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:
-   - /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
-
- # or:
-
- 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.org/project/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/*
-
-You can also use the ``.gitignore`` file (or any list of files) through:
-
-.. code-block:: yaml
-
- ignore-from-file: .gitignore
-
-or:
-
-.. code-block:: yaml
-
- ignore-from-file: [.gitignore, .yamlignore]
-
-.. note:: However, this is mutually exclusive with the ``ignore`` key.
-
-If you need to know the exact list of files that yamllint would process,
-without really linting them, you can use ``--list-files``:
-
-.. code:: bash
-
- yamllint --list-files .
-
-Setting the locale
-------------------
-
-It is possible to set the ``locale`` option globally. This is passed to Python's
-`locale.setlocale
-<https://docs.python.org/3/library/locale.html#locale.setlocale>`_,
-so an empty string ``""`` will use the system default locale, while e.g.
-``"en_US.UTF-8"`` will use that.
-
-Currently this only affects the ``key-ordering`` rule. The default will order
-by Unicode code point number, while locales will sort case and accents
-properly as well.
-
-.. code-block:: yaml
-
- extends: default
 
- locale: en_US.UTF-8
+In both cases, the script will output them (with different colors when using the
+``standard`` output format), but the exit code can be different. More precisely,
+the script will exit will a failure code *only when* there is one or more
+error(s).

docs/development.rst

@@ -2,17 +2,7 @@ Development
 ===========
 
 yamllint provides both a script and a Python module. The latter can be used to
-write your own linting tools.
+write your own linting tools:
-
-Basic example of running the linter from Python:
-
-.. code-block:: python
-
-   import yamllint
-
-   yaml_config = yamllint.config.YamlLintConfig("extends: default")
-   for p in yamllint.linter.run(open("example.yaml", "r"), yaml_config):
-       print(p.desc, p.line, p.rule)
 
 .. automodule:: yamllint.linter
    :members:

docs/disable_with_comments.rst

@@ -1,136 +0,0 @@
-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}
-
-You can't make yamllint ignore invalid YAML syntax on a line (which generates a
-`syntax error`), such as when templating a YAML file with Jinja. In some cases,
-you can workaround this by putting the templating syntax in a YAML comment. See
-`Putting template flow control in comments`_.
-
-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.
-
-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
-
-Putting template flow control in comments
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Alternatively for templating you can wrap the template statements in comments
-to make it a valid YAML file. As long as the templating language doesn't use
-the same comment symbol, it should be a valid template and valid YAML (pre and
-post-template processing).
-
-Example of a Jinja2 code that cannot be parsed as YAML because it contains
-invalid tokens ``{%`` and ``%}``:
-
-.. code-block:: text
-
- # This file IS NOT valid YAML and will produce syntax errors
- {% if extra_info %}
- key1: value1
- {% endif %}
- key2: value2
-
-But it can be fixed using YAML comments:
-
-.. code-block:: yaml
-
- # This file IS valid YAML because the Jinja is in a YAML comment
- # {% if extra_info %}
- key1: value1
- # {% endif %}
- key2: value2

docs/index.rst

@@ -11,7 +11,7 @@ Screenshot
 
 .. note::
 
-   The default output format is inspired by `eslint <https://eslint.org/>`_, a
+   The default output format is inspired by `eslint <http://eslint.org/>`_, a
    great linting tool for Javascript.
 
 Table of contents
@@ -23,7 +23,5 @@ Table of contents
    quickstart
    configuration
    rules
-   disable_with_comments
    development
    text_editors
-   integration

docs/integration.rst

@@ -1,67 +0,0 @@
-Integration with other software
-===============================
-
-Integration with pre-commit
----------------------------
-
-You can integrate yamllint in the `pre-commit <https://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.
-  repos:
-    - repo: https://github.com/adrienverge/yamllint.git
-      rev: v1.29.0
-      hooks:
-        - id: yamllint
-          args: [--strict, -c=/path/to/.yamllint]
-
-
-Integration with GitHub Actions
--------------------------------
-
-yamllint auto-detects when it's running inside of `GitHub
-Actions <https://github.com/features/actions>`_ and automatically uses the
-suited output format to decorate code with linting errors. You can also force
-the GitHub Actions output with ``yamllint --format github``.
-
-A minimal example workflow using GitHub Actions:
-
-.. code:: yaml
-
-   ---
-   on: push  # yamllint disable-line rule:truthy
-
-   jobs:
-     lint:
-       runs-on: ubuntu-latest
-       steps:
-         - uses: actions/checkout@v3
-
-         - name: Install yamllint
-           run: pip install yamllint
-
-         - name: Lint YAML files
-           run: yamllint .
-
-Integration with Arcanist
--------------------------
-
-You can configure yamllint to run on ``arc lint``. Here is an example
-``.arclint`` file that makes use of this configuration.
-
-.. code:: json
-
-  {
-    "linters": {
-      "yamllint": {
-        "type": "script-and-regex",
-        "script-and-regex.script": "yamllint",
-        "script-and-regex.regex": "/^(?P<line>\\d+):(?P<offset>\\d+) +(?P<severity>warning|error) +(?P<message>.*) +\\((?P<name>.*)\\)$/m",
-        "include": "(\\.(yml|yaml)$)"
-      }
-    }
-  }

docs/quickstart.rst

@@ -4,49 +4,37 @@ Quickstart
 Installing yamllint
 -------------------
 
-On Fedora / CentOS (note: `EPEL <https://docs.fedoraproject.org/en-US/epel/>`_ is
+On Fedora / CentOS:
-required on CentOS):
 
 .. code:: bash
 
  sudo dnf install yamllint
 
-On Debian 8+ / Ubuntu 16.04+:
+On Debian 9+ / Ubuntu 16.04+:
 
 .. code:: bash
 
  sudo apt-get install yamllint
 
-On Mac OS 10.11+:
+On older Debian / Ubuntu versions:
 
 .. code:: bash
 
- brew install yamllint
+ sudo add-apt-repository -y ppa:adrienverge/ppa && sudo apt-get update
-
+ sudo apt-get 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
+ sudo pip install yamllint
 
 If you prefer installing from source, you can run, from the source directory:
 
 .. code:: bash
 
- python -m build
+ python setup.py sdist
- pip install --user dist/yamllint-*.tar.gz
+ sudo pip install dist/yamllint-*.tar.gz
 
 Running yamllint
 ----------------
@@ -63,12 +51,6 @@ You can also lint all YAML files in a whole directory:
 
  yamllint .
 
-Or lint a YAML stream from standard input:
-
-.. code:: bash
-
- echo -e 'this: is\nvalid: YAML' | yamllint -
-
 The output will look like (colors are not displayed here):
 
 ::
@@ -87,10 +69,6 @@ The output will look like (colors are not displayed here):
    10:1      error    too many blank lines (4 > 2)  (empty-lines)
    11:4      error    too many spaces inside braces  (braces)
 
-By default, the output of yamllint is colored when run from a terminal, and
-pure text in other cases. Add the ``-f standard`` arguments to force
-non-colored output. Use the ``-f colored`` arguments to force colored output.
-
 Add the ``-f parsable`` arguments if you need an output format parsable by a
 machine (for instance for :doc:`syntax highlighting in text editors
 <text_editors>`). The output will then look like:

docs/rules.rst

@@ -14,11 +14,6 @@ This page describes the rules and their options.
    :local:
    :depth: 1
 
-anchors
--------
-
-.. automodule:: yamllint.rules.anchors
-
 braces
 ------
 
@@ -64,17 +59,6 @@ empty-lines
 
 .. automodule:: yamllint.rules.empty_lines
 
-empty-values
-------------
-
-.. automodule:: yamllint.rules.empty_values
-
-float-values
-------------
-
-.. automodule:: yamllint.rules.float_values
-
-
 hyphens
 -------
 
@@ -90,11 +74,6 @@ key-duplicates
 
 .. automodule:: yamllint.rules.key_duplicates
 
-key-ordering
---------------
-
-.. automodule:: yamllint.rules.key_ordering
-
 line-length
 -----------
 
@@ -110,22 +89,7 @@ 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,12 +9,8 @@ text editor.
 Vim
 ---
 
-Assuming that the `ALE <https://github.com/dense-analysis/ale>`_ plugin is
+Assuming that the `syntastic <https://github.com/scrooloose/syntastic>`_ plugin
-installed, yamllint is supported by default. It is automatically enabled when
+is installed, add to your ``.vimrc``:
-editing YAML files.
-
-If you instead use the `syntastic <https://github.com/vim-syntastic/syntastic>`_
-plugin, add this to your ``.vimrc``:
 
 ::
 
@@ -23,26 +19,10 @@ plugin, add this to your ``.vimrc``:
 Neovim
 ------
 
-Assuming that the `neomake <https://github.com/neomake/neomake>`_ plugin is
+Assuming that the `neomake <https://github.com/benekastah/neomake>`_ plugin is
 installed, yamllint is supported by default. It is automatically enabled when
 editing YAML files.
 
-Emacs
------
-
-If you are `flycheck <https://github.com/flycheck/flycheck>`_ user, you can use
-`flycheck-yamllint <https://github.com/krzysztof-magosa/flycheck-yamllint>`_ integration.
-
-Visual Studio Code
-------------------
-
-https://marketplace.visualstudio.com/items?itemName=fnando.linter
-
-IntelliJ
---------
-
-https://plugins.jetbrains.com/plugin/15349-yamllint
-
 Other text editors
 ------------------
 

pyproject.toml

@@ -1,54 +0,0 @@
-[project]
-name = "yamllint"
-description = "A linter for YAML files."
-readme = {file = "README.rst", content-type = "text/x-rst"}
-requires-python = ">=3.7"
-license = {text = "GPL-3.0-or-later"}
-authors = [{name = "Adrien Vergé"}]
-keywords = ["yaml", "lint", "linter", "syntax", "checker"]
-classifiers = [
-    "Development Status :: 5 - Production/Stable",
-    "Environment :: Console",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
-    "Programming Language :: Python",
-    "Topic :: Software Development",
-    "Topic :: Software Development :: Debuggers",
-    "Topic :: Software Development :: Quality Assurance",
-    "Topic :: Software Development :: Testing",
-]
-dependencies = [
-    "pathspec >= 0.5.3",
-    "pyyaml",
-]
-dynamic = ["version"]
-
-[project.optional-dependencies]
-dev = [
-    "doc8",
-    "flake8",
-    "flake8-import-order",
-    "rstcheck[sphinx]",
-    "sphinx",
-]
-
-[project.scripts]
-yamllint = "yamllint.cli:run"
-
-[project.urls]
-homepage = "https://github.com/adrienverge/yamllint"
-repository = "https://github.com/adrienverge/yamllint"
-documentation = "https://yamllint.readthedocs.io"
-
-[build-system]
-build-backend = "setuptools.build_meta"
-requires = ["setuptools >= 61"]
-
-[tool.setuptools]
-packages = ["yamllint", "yamllint.conf", "yamllint.rules"]
-
-[tool.setuptools.package-data]
-yamllint = ["conf/*.yaml"]
-
-[tool.setuptools.dynamic]
-version = {attr = "yamllint.__version__"}

setup.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -13,8 +14,39 @@
 # 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
+from setuptools import setup, find_packages
 
-# This is only kept for backward-compatibility with older versions that don't
+from yamllint import (__author__, __license__,
-# support new packaging standards (e.g. PEP 517 or PEP 660):
+                      APP_NAME, APP_VERSION, APP_DESCRIPTION)
-setup()
+
+
+setup(
+    name=APP_NAME,
+    version=APP_VERSION,
+    author=__author__,
+    description=APP_DESCRIPTION.split('\n')[0],
+    long_description=APP_DESCRIPTION,
+    license=__license__,
+    keywords=['yaml', 'lint', 'linter', 'syntax', 'checker'],
+    url='https://github.com/adrienverge/yamllint',
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Environment :: Console',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
+        'Programming Language :: Python :: 2',
+        'Programming Language :: Python :: 3',
+        'Topic :: Software Development',
+        'Topic :: Software Development :: Debuggers',
+        'Topic :: Software Development :: Quality Assurance',
+        'Topic :: Software Development :: Testing',
+    ],
+
+    packages=find_packages(),
+    entry_points={'console_scripts': ['yamllint=yamllint.cli:run']},
+    package_data={'yamllint': ['conf/*.yaml'],
+                  'tests': ['yaml-1.2-spec-examples/*']},
+    install_requires=['pyyaml'],
+    tests_require=['nose'],
+    test_suite='nose.collector',
+)

tests/__init__.py

@@ -1,19 +0,0 @@
-# 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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -13,10 +14,6 @@
 # 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 contextlib
-import os
-import shutil
-import tempfile
 import unittest
 
 import yaml
@@ -52,35 +49,3 @@ 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).encode('utf-8')
-        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
-
-
-@contextlib.contextmanager
-def temp_workspace(files):
-    """Provide a temporary workspace that is automatically cleaned up."""
-    backup_wd = os.getcwd()
-    wd = build_temp_workspace(files)
-
-    try:
-        os.chdir(wd)
-        yield
-    finally:
-        os.chdir(backup_wd)
-        shutil.rmtree(wd)

tests/rules/test_anchors.py

@@ -1,281 +0,0 @@
-# Copyright (C) 2023 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 AnchorsTestCase(RuleTestCase):
-    rule_id = 'anchors'
-
-    def test_disabled(self):
-        conf = 'anchors: disable'
-        self.check('---\n'
-                   '- &b true\n'
-                   '- &i 42\n'
-                   '- &s hello\n'
-                   '- &f_m {k: v}\n'
-                   '- &f_s [1, 2]\n'
-                   '- *b\n'
-                   '- *i\n'
-                   '- *s\n'
-                   '- *f_m\n'
-                   '- *f_s\n'
-                   '---\n'  # redeclare anchors in a new document
-                   '- &b true\n'
-                   '- &i 42\n'
-                   '- &s hello\n'
-                   '- *b\n'
-                   '- *i\n'
-                   '- *s\n'
-                   '---\n'
-                   'block mapping: &b_m\n'
-                   '  key: value\n'
-                   'extended:\n'
-                   '  <<: *b_m\n'
-                   '  foo: bar\n'
-                   '---\n'
-                   '{a: 1, &x b: 2, c: &y 3, *x : 4, e: *y}\n'
-                   '...\n', conf)
-        self.check('---\n'
-                   '- &i 42\n'
-                   '---\n'
-                   '- &b true\n'
-                   '- &b true\n'
-                   '- &b true\n'
-                   '- &s hello\n'
-                   '- *b\n'
-                   '- *i\n'    # declared in a previous document
-                   '- *f_m\n'  # never declared
-                   '- *f_m\n'
-                   '- *f_m\n'
-                   '- *f_s\n'  # declared after
-                   '- &f_s [1, 2]\n'
-                   '---\n'
-                   'block mapping: &b_m\n'
-                   '  key: value\n'
-                   '---\n'
-                   'block mapping 1: &b_m_bis\n'
-                   '  key: value\n'
-                   'block mapping 2: &b_m_bis\n'
-                   '  key: value\n'
-                   'extended:\n'
-                   '  <<: *b_m\n'
-                   '  foo: bar\n'
-                   '---\n'
-                   '{a: 1, &x b: 2, c: &x 3, *x : 4, e: *y}\n'
-                   '...\n', conf)
-
-    def test_forbid_undeclared_aliases(self):
-        conf = ('anchors:\n'
-                '  forbid-undeclared-aliases: true\n'
-                '  forbid-duplicated-anchors: false\n'
-                '  forbid-unused-anchors: false\n')
-        self.check('---\n'
-                   '- &b true\n'
-                   '- &i 42\n'
-                   '- &s hello\n'
-                   '- &f_m {k: v}\n'
-                   '- &f_s [1, 2]\n'
-                   '- *b\n'
-                   '- *i\n'
-                   '- *s\n'
-                   '- *f_m\n'
-                   '- *f_s\n'
-                   '---\n'  # redeclare anchors in a new document
-                   '- &b true\n'
-                   '- &i 42\n'
-                   '- &s hello\n'
-                   '- *b\n'
-                   '- *i\n'
-                   '- *s\n'
-                   '---\n'
-                   'block mapping: &b_m\n'
-                   '  key: value\n'
-                   'extended:\n'
-                   '  <<: *b_m\n'
-                   '  foo: bar\n'
-                   '---\n'
-                   '{a: 1, &x b: 2, c: &y 3, *x : 4, e: *y}\n'
-                   '...\n', conf)
-        self.check('---\n'
-                   '- &i 42\n'
-                   '---\n'
-                   '- &b true\n'
-                   '- &b true\n'
-                   '- &b true\n'
-                   '- &s hello\n'
-                   '- *b\n'
-                   '- *i\n'    # declared in a previous document
-                   '- *f_m\n'  # never declared
-                   '- *f_m\n'
-                   '- *f_m\n'
-                   '- *f_s\n'  # declared after
-                   '- &f_s [1, 2]\n'
-                   '...\n'
-                   '---\n'
-                   'block mapping: &b_m\n'
-                   '  key: value\n'
-                   '---\n'
-                   'block mapping 1: &b_m_bis\n'
-                   '  key: value\n'
-                   'block mapping 2: &b_m_bis\n'
-                   '  key: value\n'
-                   'extended:\n'
-                   '  <<: *b_m\n'
-                   '  foo: bar\n'
-                   '---\n'
-                   '{a: 1, &x b: 2, c: &x 3, *x : 4, e: *y}\n'
-                   '...\n', conf,
-                   problem1=(9, 3),
-                   problem2=(10, 3),
-                   problem3=(11, 3),
-                   problem4=(12, 3),
-                   problem5=(13, 3),
-                   problem6=(25, 7),
-                   problem7=(28, 37))
-
-    def test_forbid_duplicated_anchors(self):
-        conf = ('anchors:\n'
-                '  forbid-undeclared-aliases: false\n'
-                '  forbid-duplicated-anchors: true\n'
-                '  forbid-unused-anchors: false\n')
-        self.check('---\n'
-                   '- &b true\n'
-                   '- &i 42\n'
-                   '- &s hello\n'
-                   '- &f_m {k: v}\n'
-                   '- &f_s [1, 2]\n'
-                   '- *b\n'
-                   '- *i\n'
-                   '- *s\n'
-                   '- *f_m\n'
-                   '- *f_s\n'
-                   '---\n'  # redeclare anchors in a new document
-                   '- &b true\n'
-                   '- &i 42\n'
-                   '- &s hello\n'
-                   '- *b\n'
-                   '- *i\n'
-                   '- *s\n'
-                   '---\n'
-                   'block mapping: &b_m\n'
-                   '  key: value\n'
-                   'extended:\n'
-                   '  <<: *b_m\n'
-                   '  foo: bar\n'
-                   '---\n'
-                   '{a: 1, &x b: 2, c: &y 3, *x : 4, e: *y}\n'
-                   '...\n', conf)
-        self.check('---\n'
-                   '- &i 42\n'
-                   '---\n'
-                   '- &b true\n'
-                   '- &b true\n'
-                   '- &b true\n'
-                   '- &s hello\n'
-                   '- *b\n'
-                   '- *i\n'    # declared in a previous document
-                   '- *f_m\n'  # never declared
-                   '- *f_m\n'
-                   '- *f_m\n'
-                   '- *f_s\n'  # declared after
-                   '- &f_s [1, 2]\n'
-                   '...\n'
-                   '---\n'
-                   'block mapping: &b_m\n'
-                   '  key: value\n'
-                   '---\n'
-                   'block mapping 1: &b_m_bis\n'
-                   '  key: value\n'
-                   'block mapping 2: &b_m_bis\n'
-                   '  key: value\n'
-                   'extended:\n'
-                   '  <<: *b_m\n'
-                   '  foo: bar\n'
-                   '---\n'
-                   '{a: 1, &x b: 2, c: &x 3, *x : 4, e: *y}\n'
-                   '...\n', conf,
-                   problem1=(5, 3),
-                   problem2=(6, 3),
-                   problem3=(22, 18),
-                   problem4=(28, 20))
-
-    def test_forbid_unused_anchors(self):
-        conf = ('anchors:\n'
-                '  forbid-undeclared-aliases: false\n'
-                '  forbid-duplicated-anchors: false\n'
-                '  forbid-unused-anchors: true\n')
-
-        self.check('---\n'
-                   '- &b true\n'
-                   '- &i 42\n'
-                   '- &s hello\n'
-                   '- &f_m {k: v}\n'
-                   '- &f_s [1, 2]\n'
-                   '- *b\n'
-                   '- *i\n'
-                   '- *s\n'
-                   '- *f_m\n'
-                   '- *f_s\n'
-                   '---\n'  # redeclare anchors in a new document
-                   '- &b true\n'
-                   '- &i 42\n'
-                   '- &s hello\n'
-                   '- *b\n'
-                   '- *i\n'
-                   '- *s\n'
-                   '---\n'
-                   'block mapping: &b_m\n'
-                   '  key: value\n'
-                   'extended:\n'
-                   '  <<: *b_m\n'
-                   '  foo: bar\n'
-                   '---\n'
-                   '{a: 1, &x b: 2, c: &y 3, *x : 4, e: *y}\n'
-                   '...\n', conf)
-        self.check('---\n'
-                   '- &i 42\n'
-                   '---\n'
-                   '- &b true\n'
-                   '- &b true\n'
-                   '- &b true\n'
-                   '- &s hello\n'
-                   '- *b\n'
-                   '- *i\n'    # declared in a previous document
-                   '- *f_m\n'  # never declared
-                   '- *f_m\n'
-                   '- *f_m\n'
-                   '- *f_s\n'  # declared after
-                   '- &f_s [1, 2]\n'
-                   '...\n'
-                   '---\n'
-                   'block mapping: &b_m\n'
-                   '  key: value\n'
-                   '---\n'
-                   'block mapping 1: &b_m_bis\n'
-                   '  key: value\n'
-                   'block mapping 2: &b_m_bis\n'
-                   '  key: value\n'
-                   'extended:\n'
-                   '  <<: *b_m\n'
-                   '  foo: bar\n'
-                   '---\n'
-                   '{a: 1, &x b: 2, c: &x 3, *x : 4, e: *y}\n'
-                   '...\n', conf,
-                   problem1=(2, 3),
-                   problem2=(7, 3),
-                   problem3=(14, 3),
-                   problem4=(17, 16),
-                   problem5=(22, 18))

tests/rules/test_braces.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -30,74 +31,12 @@ class ColonTestCase(RuleTestCase):
                    'dict6: {  a: 1, b, c: 3 }\n'
                    'dict7: {   a: 1, b, c: 3 }\n', conf)
 
-    def test_forbid(self):
-        conf = ('braces:\n'
-                '  forbid: false\n')
-        self.check('---\n'
-                   'dict: {}\n', conf)
-        self.check('---\n'
-                   'dict: {a}\n', conf)
-        self.check('---\n'
-                   'dict: {a: 1}\n', conf)
-        self.check('---\n'
-                   'dict: {\n'
-                   '  a: 1\n'
-                   '}\n', conf)
-
-        conf = ('braces:\n'
-                '  forbid: true\n')
-        self.check('---\n'
-                   'dict:\n'
-                   '  a: 1\n', conf)
-        self.check('---\n'
-                   'dict: {}\n', conf, problem=(2, 8))
-        self.check('---\n'
-                   'dict: {a}\n', conf, problem=(2, 8))
-        self.check('---\n'
-                   'dict: {a: 1}\n', conf, problem=(2, 8))
-        self.check('---\n'
-                   'dict: {\n'
-                   '  a: 1\n'
-                   '}\n', conf, problem=(2, 8))
-
-        conf = ('braces:\n'
-                '  forbid: non-empty\n')
-        self.check('---\n'
-                   'dict:\n'
-                   '  a: 1\n', conf)
-        self.check('---\n'
-                   'dict: {}\n', conf)
-        self.check('---\n'
-                   'dict: {\n'
-                   '}\n', conf)
-        self.check('---\n'
-                   'dict: {\n'
-                   '# commented: value\n'
-                   '# another: value2\n'
-                   '}\n', conf)
-        self.check('---\n'
-                   'dict: {a}\n', conf, problem=(2, 8))
-        self.check('---\n'
-                   'dict: {a: 1}\n', conf, problem=(2, 8))
-        self.check('---\n'
-                   'dict: {\n'
-                   '  a: 1\n'
-                   '}\n', conf, problem=(2, 8))
-
     def test_min_spaces(self):
-        conf = ('braces:\n'
+        conf = 'braces: {max-spaces-inside: -1, min-spaces-inside: 0}'
-                '  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:\n'
+        conf = 'braces: {max-spaces-inside: -1, min-spaces-inside: 1}'
-                '  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'
@@ -113,11 +52,7 @@ class ColonTestCase(RuleTestCase):
                    '  b\n'
                    '}\n', conf)
 
-        conf = ('braces:\n'
+        conf = 'braces: {max-spaces-inside: -1, min-spaces-inside: 3}'
-                '  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))
@@ -125,11 +60,7 @@ class ColonTestCase(RuleTestCase):
                    'dict: {   a: 1, b   }\n', conf)
 
     def test_max_spaces(self):
-        conf = ('braces:\n'
+        conf = 'braces: {max-spaces-inside: 0, min-spaces-inside: -1}'
-                '  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'
@@ -148,11 +79,7 @@ class ColonTestCase(RuleTestCase):
                    '  b\n'
                    '}\n', conf)
 
-        conf = ('braces:\n'
+        conf = 'braces: {max-spaces-inside: 3, min-spaces-inside: -1}'
-                '  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'
@@ -160,11 +87,7 @@ class ColonTestCase(RuleTestCase):
                    problem1=(2, 11), problem2=(2, 23))
 
     def test_min_and_max_spaces(self):
-        conf = ('braces:\n'
+        conf = 'braces: {max-spaces-inside: 0, min-spaces-inside: 0}'
-                '  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'
@@ -172,169 +95,14 @@ class ColonTestCase(RuleTestCase):
         self.check('---\n'
                    'dict: {   a: 1, b}\n', conf, problem=(2, 10))
 
-        conf = ('braces:\n'
+        conf = 'braces: {max-spaces-inside: 1, min-spaces-inside: 1}'
-                '  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:\n'
+        conf = 'braces: {max-spaces-inside: 2, min-spaces-inside: 0}'
-                '  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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -30,72 +31,12 @@ class ColonTestCase(RuleTestCase):
                    'array6: [  a, b, c ]\n'
                    'array7: [   a, b, c ]\n', conf)
 
-    def test_forbid(self):
-        conf = ('brackets:\n'
-                '  forbid: false\n')
-        self.check('---\n'
-                   'array: []\n', conf)
-        self.check('---\n'
-                   'array: [a, b]\n', conf)
-        self.check('---\n'
-                   'array: [\n'
-                   '  a,\n'
-                   '  b\n'
-                   ']\n', conf)
-
-        conf = ('brackets:\n'
-                '  forbid: true\n')
-        self.check('---\n'
-                   'array:\n'
-                   '  - a\n'
-                   '  - b\n', conf)
-        self.check('---\n'
-                   'array: []\n', conf, problem=(2, 9))
-        self.check('---\n'
-                   'array: [a, b]\n', conf, problem=(2, 9))
-        self.check('---\n'
-                   'array: [\n'
-                   '  a,\n'
-                   '  b\n'
-                   ']\n', conf, problem=(2, 9))
-
-        conf = ('brackets:\n'
-                '  forbid: non-empty\n')
-        self.check('---\n'
-                   'array:\n'
-                   '  - a\n'
-                   '  - b\n', conf)
-        self.check('---\n'
-                   'array: []\n', conf)
-        self.check('---\n'
-                   'array: [\n\n'
-                   ']\n', conf)
-        self.check('---\n'
-                   'array: [\n'
-                   '# a comment\n'
-                   ']\n', conf)
-        self.check('---\n'
-                   'array: [a, b]\n', conf, problem=(2, 9))
-        self.check('---\n'
-                   'array: [\n'
-                   '  a,\n'
-                   '  b\n'
-                   ']\n', conf, problem=(2, 9))
-
     def test_min_spaces(self):
-        conf = ('brackets:\n'
+        conf = 'brackets: {max-spaces-inside: -1, min-spaces-inside: 0}'
-                '  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:\n'
+        conf = 'brackets: {max-spaces-inside: -1, min-spaces-inside: 1}'
-                '  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'
@@ -110,11 +51,7 @@ class ColonTestCase(RuleTestCase):
                    '  b\n'
                    ']\n', conf)
 
-        conf = ('brackets:\n'
+        conf = 'brackets: {max-spaces-inside: -1, min-spaces-inside: 3}'
-                '  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))
@@ -122,11 +59,7 @@ class ColonTestCase(RuleTestCase):
                    'array: [   a, b   ]\n', conf)
 
     def test_max_spaces(self):
-        conf = ('brackets:\n'
+        conf = 'brackets: {max-spaces-inside: 0, min-spaces-inside: -1}'
-                '  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'
@@ -145,11 +78,7 @@ class ColonTestCase(RuleTestCase):
                    '  b\n'
                    ']\n', conf)
 
-        conf = ('brackets:\n'
+        conf = 'brackets: {max-spaces-inside: 3, min-spaces-inside: -1}'
-                '  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'
@@ -157,11 +86,7 @@ class ColonTestCase(RuleTestCase):
                    problem1=(2, 12), problem2=(2, 21))
 
     def test_min_and_max_spaces(self):
-        conf = ('brackets:\n'
+        conf = 'brackets: {max-spaces-inside: 0, min-spaces-inside: 0}'
-                '  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'
@@ -169,169 +94,14 @@ class ColonTestCase(RuleTestCase):
         self.check('---\n'
                    'array: [   a, b]\n', conf, problem=(2, 11))
 
-        conf = ('brackets:\n'
+        conf = 'brackets: {max-spaces-inside: 1, min-spaces-inside: 1}'
-                '  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:\n'
+        conf = 'brackets: {max-spaces-inside: 2, min-spaces-inside: 0}'
-                '  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_colons.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -256,19 +257,3 @@ class ColonTestCase(RuleTestCase):
                    '  property: {a: 1, b:  2, c : 3}\n', conf,
                    problem1=(3, 11), problem2=(4, 4),
                    problem3=(8, 23), problem4=(8, 28))
-
-    # Although accepted by PyYAML, `{*x: 4}` is not valid YAML: it should be
-    # noted `{*x : 4}`. The reason is that a colon can be part of an anchor
-    # name. See commit message for more details.
-    def test_with_alias_as_key(self):
-        conf = 'colons: {max-spaces-before: 0, max-spaces-after: 1}'
-        self.check('---\n'
-                   '- anchor: &a key\n'
-                   '- *a: 42\n'
-                   '- {*a: 42}\n'
-                   '- *a : 42\n'
-                   '- {*a : 42}\n'
-                   '- *a  : 42\n'
-                   '- {*a  : 42}\n',
-                   conf,
-                   problem1=(7, 6), problem2=(8, 7))

tests/rules/test_commas.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify

tests/rules/test_comments.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -34,15 +35,11 @@ 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: true\n'
+                '  require-starting-space: yes\n'
                 '  min-spaces-from-content: -1\n'
                 'comments-indentation: disable\n')
         self.check('---\n'
@@ -55,11 +52,7 @@ class CommentsTestCase(RuleTestCase):
                    '# comment 2\n'
                    '# comment 3\n'
                    '  #  comment 3 bis\n'
-                   '  #  comment 3 ter\n'
+                   '  #  comment 3 ter\n', conf)
-                   '\n'
-                   '################################\n'
-                   '## comment 4\n'
-                   '##  comment 5\n', conf)
         self.check('---\n'
                    '#comment\n'
                    '\n'
@@ -70,59 +63,13 @@ class CommentsTestCase(RuleTestCase):
                    '# comment 2\n'
                    '#comment 3\n'
                    '  #comment 3 bis\n'
-                   '  #  comment 3 ter\n'
+                   '  #  comment 3 ter\n', conf,
-                   '\n'
-                   '################################\n'
-                   '## comment 4\n'
-                   '##comment 5\n', conf,
                    problem1=(2, 2), problem2=(6, 13),
-                   problem3=(9, 2), problem4=(10, 4),
+                   problem4=(9, 2), problem5=(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('#! is a valid shebang too\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('#! is a valid shebang too\n', conf)
-        self.check('key:  #!/not/a/shebang\n',
-                   conf, problem1=(1, 8))
 
     def test_spaces_from_content(self):
         conf = ('comments:\n'
-                '  require-starting-space: false\n'
+                '  require-starting-space: no\n'
                 '  min-spaces-from-content: 2\n')
         self.check('---\n'
                    '# comment\n'
@@ -144,7 +91,7 @@ class CommentsTestCase(RuleTestCase):
 
     def test_both(self):
         conf = ('comments:\n'
-                '  require-starting-space: true\n'
+                '  require-starting-space: yes\n'
                 '  min-spaces-from-content: 2\n'
                 'comments-indentation: disable\n')
         self.check('---\n'
@@ -159,22 +106,17 @@ 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=(15, 3),
+                   problem7=(13, 30))
-                   problem8=(17, 30))
 
     def test_empty_comment(self):
         conf = ('comments:\n'
-                '  require-starting-space: true\n'
+                '  require-starting-space: yes\n'
                 '  min-spaces-from-content: 2\n')
         self.check('---\n'
                    '# This is paragraph 1.\n'
@@ -184,44 +126,15 @@ class CommentsTestCase(RuleTestCase):
                    'inline: comment  #\n'
                    'foo: bar\n', conf)
 
-    def test_empty_comment_crlf_dos_newlines(self):
-        conf = ('comments:\n'
-                '  require-starting-space: true\n'
-                '  min-spaces-from-content: 2\n'
-                'new-lines:\n'
-                '  type: dos\n')
-        self.check('---\r\n'
-                   '# This is paragraph 1.\r\n'
-                   '#\r\n'
-                   '# This is paragraph 2.\r\n', conf)
-
-    def test_empty_comment_crlf_disabled_newlines(self):
-        conf = ('comments:\n'
-                '  require-starting-space: true\n'
-                '  min-spaces-from-content: 2\n'
-                'new-lines: disable\n')
-        self.check('---\r\n'
-                   '# This is paragraph 1.\r\n'
-                   '#\r\n'
-                   '# This is paragraph 2.\r\n', conf)
-
     def test_first_line(self):
         conf = ('comments:\n'
-                '  require-starting-space: true\n'
+                '  require-starting-space: yes\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: true\n'
+                '  require-starting-space: yes\n'
                 '  min-spaces-from-content: 2\n'
                 'trailing-spaces: disable\n')
         self.check('---\n'

tests/rules/test_comments_indentation.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -57,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))
+                   '  # line 2\n', conf, problem1=(2, 3), problem2=(3, 3))
         self.check('---\n'
                    'obj:\n'
                    '  # normal\n'
@@ -101,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'
@@ -142,15 +143,3 @@ 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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -17,7 +18,8 @@ import unittest
 
 import yaml
 
-from yamllint.rules.common import get_line_indent
+from yamllint.rules.common import (Comment, get_line_indent,
+                                   get_comments_between_tokens)
 
 
 class CommonTestCase(unittest.TestCase):
@@ -41,3 +43,54 @@ 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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -30,7 +31,7 @@ class DocumentEndTestCase(RuleTestCase):
                    '  document: end\n', conf)
 
     def test_required(self):
-        conf = 'document-end: {present: true}'
+        conf = 'document-end: {present: yes}'
         self.check('', conf)
         self.check('\n', conf)
         self.check('---\n'
@@ -42,7 +43,7 @@ class DocumentEndTestCase(RuleTestCase):
                    '  document: end\n', conf, problem=(3, 1))
 
     def test_forbidden(self):
-        conf = 'document-end: {present: false}'
+        conf = 'document-end: {present: no}'
         self.check('---\n'
                    'with:\n'
                    '  document: end\n'
@@ -52,7 +53,7 @@ class DocumentEndTestCase(RuleTestCase):
                    '  document: end\n', conf)
 
     def test_multiple_documents(self):
-        conf = ('document-end: {present: true}\n'
+        conf = ('document-end: {present: yes}\n'
                 'document-start: disable\n')
         self.check('---\n'
                    'first: document\n'
@@ -71,22 +72,3 @@ class DocumentEndTestCase(RuleTestCase):
                    '---\n'
                    'third: document\n'
                    '...\n', conf, problem=(6, 1))
-
-    def test_directives(self):
-        conf = 'document-end: {present: true}'
-        self.check('%YAML 1.2\n'
-                   '---\n'
-                   'document: end\n'
-                   '...\n', conf)
-        self.check('%YAML 1.2\n'
-                   '%TAG ! tag:clarkevans.com,2002:\n'
-                   '---\n'
-                   'document: end\n'
-                   '...\n', conf)
-        self.check('---\n'
-                   'first: document\n'
-                   '...\n'
-                   '%YAML 1.2\n'
-                   '---\n'
-                   'second: document\n'
-                   '...\n', conf)

tests/rules/test_document_start.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -27,7 +28,7 @@ class DocumentStartTestCase(RuleTestCase):
                    'key: val\n', conf)
 
     def test_required(self):
-        conf = ('document-start: {present: true}\n'
+        conf = ('document-start: {present: yes}\n'
                 'empty-lines: disable\n')
         self.check('', conf)
         self.check('\n', conf)
@@ -43,7 +44,7 @@ class DocumentStartTestCase(RuleTestCase):
                    'key: val\n', conf)
 
     def test_forbidden(self):
-        conf = ('document-start: {present: false}\n'
+        conf = ('document-start: {present: no}\n'
                 'empty-lines: disable\n')
         self.check('', conf)
         self.check('key: val\n', conf)
@@ -61,7 +62,7 @@ class DocumentStartTestCase(RuleTestCase):
                    'key: val\n', conf, problem=(2, 1))
 
     def test_multiple_documents(self):
-        conf = 'document-start: {present: true}'
+        conf = 'document-start: {present: yes}'
         self.check('---\n'
                    'first: document\n'
                    '...\n'
@@ -84,7 +85,7 @@ class DocumentStartTestCase(RuleTestCase):
                    'third: document\n', conf, problem=(4, 1, 'syntax'))
 
     def test_directives(self):
-        conf = 'document-start: {present: true}'
+        conf = 'document-start: {present: yes}'
         self.check('%YAML 1.2\n'
                    '---\n'
                    'doc: ument\n'

tests/rules/test_empty_lines.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -77,22 +78,3 @@ 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

@@ -1,260 +0,0 @@
-# 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_float_values.py

@@ -1,128 +0,0 @@
-# Copyright (C) 2022 the yamllint contributors
-#
-# 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 FloatValuesTestCase(RuleTestCase):
-    rule_id = 'float-values'
-
-    def test_disabled(self):
-        conf = 'float-values: disable\n'
-        self.check('---\n'
-                   '- 0.0\n'
-                   '- .NaN\n'
-                   '- .INF\n'
-                   '- .1\n'
-                   '- 10e-6\n',
-                   conf)
-
-    def test_numeral_before_decimal(self):
-        conf = (
-            'float-values:\n'
-            '  require-numeral-before-decimal: true\n'
-            '  forbid-scientific-notation: false\n'
-            '  forbid-nan: false\n'
-            '  forbid-inf: false\n')
-        self.check('---\n'
-                   '- 0.0\n'
-                   '- .1\n'
-                   '- \'.1\'\n'
-                   '- string.1\n'
-                   '- .1string\n'
-                   '- !custom_tag .2\n'
-                   '- &angle1 0.0\n'
-                   '- *angle1\n'
-                   '- &angle2 .3\n'
-                   '- *angle2\n',
-                   conf,
-                   problem1=(3, 3),
-                   problem2=(10, 11))
-
-    def test_scientific_notation(self):
-        conf = (
-            'float-values:\n'
-            '  require-numeral-before-decimal: false\n'
-            '  forbid-scientific-notation: true\n'
-            '  forbid-nan: false\n'
-            '  forbid-inf: false\n')
-        self.check('---\n'
-                   '- 10e6\n'
-                   '- 10e-6\n'
-                   '- 0.00001\n'
-                   '- \'10e-6\'\n'
-                   '- string10e-6\n'
-                   '- 10e-6string\n'
-                   '- !custom_tag 10e-6\n'
-                   '- &angle1 0.000001\n'
-                   '- *angle1\n'
-                   '- &angle2 10e-6\n'
-                   '- *angle2\n'
-                   '- &angle3 10e6\n'
-                   '- *angle3\n',
-                   conf,
-                   problem1=(2, 3),
-                   problem2=(3, 3),
-                   problem3=(11, 11),
-                   problem4=(13, 11))
-
-    def test_nan(self):
-        conf = (
-            'float-values:\n'
-            '  require-numeral-before-decimal: false\n'
-            '  forbid-scientific-notation: false\n'
-            '  forbid-nan: true\n'
-            '  forbid-inf: false\n')
-        self.check('---\n'
-                   '- .NaN\n'
-                   '- .NAN\n'
-                   '- \'.NaN\'\n'
-                   '- a.NaN\n'
-                   '- .NaNa\n'
-                   '- !custom_tag .NaN\n'
-                   '- &angle .nan\n'
-                   '- *angle\n',
-                   conf,
-                   problem1=(2, 3),
-                   problem2=(3, 3),
-                   problem3=(8, 10))
-
-    def test_inf(self):
-        conf = (
-            'float-values:\n'
-            '  require-numeral-before-decimal: false\n'
-            '  forbid-scientific-notation: false\n'
-            '  forbid-nan: false\n'
-            '  forbid-inf: true\n')
-        self.check('---\n'
-                   '- .inf\n'
-                   '- .INF\n'
-                   '- -.inf\n'
-                   '- -.INF\n'
-                   '- \'.inf\'\n'
-                   '- ∞.infinity\n'
-                   '- .infinity∞\n'
-                   '- !custom_tag .inf\n'
-                   '- &angle .inf\n'
-                   '- *angle\n'
-                   '- &angle -.inf\n'
-                   '- *angle\n',
-                   conf,
-                   problem1=(2, 3),
-                   problem2=(3, 3),
-                   problem3=(4, 3),
-                   problem4=(5, 3),
-                   problem5=(10, 10),
-                   problem6=(12, 10))

tests/rules/test_hyphens.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify

tests/rules/test_indentation.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -14,8 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from tests.common import RuleTestCase
-
+from yamllint.parser import token_generator
-from yamllint.parser import token_or_comment_generator, Comment
 from yamllint.rules.indentation import check
 
 
@@ -38,8 +38,7 @@ class IndentationStackTestCase(RuleTestCase):
                 'check-multi-line-strings': False}
         context = {}
         output = ''
-        for elem in [t for t in token_or_comment_generator(source)
+        for elem in token_generator(source):
-                     if not isinstance(t, Comment)]:
             list(check(conf, elem.curr, elem.prev, elem.next, elem.nextnext,
                        context))
 
@@ -50,7 +49,7 @@ class IndentationStackTestCase(RuleTestCase):
                           .replace('Mapping', 'Map'))
             if token_type in ('StreamStart', 'StreamEnd'):
                 continue
-            output += '{:>9} {}\n'.format(token_type,
+            output += '%9s %s\n' % (token_type,
                                     self.format_stack(context['stack']))
         return output
 
@@ -549,7 +548,7 @@ class IndentationTestCase(RuleTestCase):
                    '...\n', conf)
 
     def test_one_space(self):
-        conf = 'indentation: {spaces: 1, indent-sequences: false}'
+        conf = 'indentation: {spaces: 1, indent-sequences: no}'
         self.check('---\n'
                    'object:\n'
                    ' k1:\n'
@@ -562,7 +561,7 @@ class IndentationTestCase(RuleTestCase):
                    ' - name: Linux\n'
                    '   date: 1991\n'
                    '...\n', conf)
-        conf = 'indentation: {spaces: 1, indent-sequences: true}'
+        conf = 'indentation: {spaces: 1, indent-sequences: yes}'
         self.check('---\n'
                    'object:\n'
                    ' k1:\n'
@@ -577,7 +576,7 @@ class IndentationTestCase(RuleTestCase):
                    '...\n', conf)
 
     def test_two_spaces(self):
-        conf = 'indentation: {spaces: 2, indent-sequences: false}'
+        conf = 'indentation: {spaces: 2, indent-sequences: no}'
         self.check('---\n'
                    'object:\n'
                    '  k1:\n'
@@ -589,11 +588,8 @@ class IndentationTestCase(RuleTestCase):
                    '    date: 1969\n'
                    '  - name: Linux\n'
                    '    date: 1991\n'
-                   '  k4:\n'
-                   '  -\n'
-                   '  k5: v3\n'
                    '...\n', conf)
-        conf = 'indentation: {spaces: 2, indent-sequences: true}'
+        conf = 'indentation: {spaces: 2, indent-sequences: yes}'
         self.check('---\n'
                    'object:\n'
                    '  k1:\n'
@@ -608,7 +604,7 @@ class IndentationTestCase(RuleTestCase):
                    '...\n', conf)
 
     def test_three_spaces(self):
-        conf = 'indentation: {spaces: 3, indent-sequences: false}'
+        conf = 'indentation: {spaces: 3, indent-sequences: no}'
         self.check('---\n'
                    'object:\n'
                    '   k1:\n'
@@ -621,7 +617,7 @@ class IndentationTestCase(RuleTestCase):
                    '   - name: Linux\n'
                    '     date: 1991\n'
                    '...\n', conf)
-        conf = 'indentation: {spaces: 3, indent-sequences: true}'
+        conf = 'indentation: {spaces: 3, indent-sequences: yes}'
         self.check('---\n'
                    'object:\n'
                    '   k1:\n'
@@ -635,7 +631,7 @@ class IndentationTestCase(RuleTestCase):
                    '        date: 1991\n'
                    '...\n', conf)
 
-    def test_consistent_spaces(self):
+    def test_consistent(self):
         conf = ('indentation: {spaces: consistent,\n'
                 '              indent-sequences: whatever}\n'
                 'document-start: disable\n')
@@ -716,142 +712,6 @@ class IndentationTestCase(RuleTestCase):
                    '- b\n'
                    '- c\n', conf)
 
-    def test_consistent_spaces_and_indent_sequences(self):
-        conf = 'indentation: {spaces: consistent, indent-sequences: true}'
-        self.check('---\n'
-                   'list one:\n'
-                   '- 1\n'
-                   '- 2\n'
-                   '- 3\n'
-                   'list two:\n'
-                   '    - a\n'
-                   '    - b\n'
-                   '    - c\n', conf, problem1=(3, 1))
-        self.check('---\n'
-                   'list one:\n'
-                   '  - 1\n'
-                   '  - 2\n'
-                   '  - 3\n'
-                   'list two:\n'
-                   '    - a\n'
-                   '    - b\n'
-                   '    - c\n', conf, problem1=(7, 5))
-        self.check('---\n'
-                   'list one:\n'
-                   '  - 1\n'
-                   '  - 2\n'
-                   '  - 3\n'
-                   'list two:\n'
-                   '- a\n'
-                   '- b\n'
-                   '- c\n', conf, problem1=(7, 1))
-
-        conf = 'indentation: {spaces: consistent, indent-sequences: false}'
-        self.check('---\n'
-                   'list one:\n'
-                   '- 1\n'
-                   '- 2\n'
-                   '- 3\n'
-                   'list two:\n'
-                   '    - a\n'
-                   '    - b\n'
-                   '    - c\n', conf, problem1=(7, 5))
-        self.check('---\n'
-                   'list one:\n'
-                   '- 1\n'
-                   '- 2\n'
-                   '- 3\n'
-                   'list two:\n'
-                   '  - a\n'
-                   '  - b\n'
-                   '  - c\n', conf, problem1=(7, 3))
-        self.check('---\n'
-                   'list one:\n'
-                   '  - 1\n'
-                   '  - 2\n'
-                   '  - 3\n'
-                   'list two:\n'
-                   '- a\n'
-                   '- b\n'
-                   '- c\n', conf, problem1=(3, 3))
-
-        conf = ('indentation: {spaces: consistent,\n'
-                '              indent-sequences: consistent}')
-        self.check('---\n'
-                   'list one:\n'
-                   '- 1\n'
-                   '- 2\n'
-                   '- 3\n'
-                   'list two:\n'
-                   '    - a\n'
-                   '    - b\n'
-                   '    - c\n', conf, problem1=(7, 5))
-        self.check('---\n'
-                   'list one:\n'
-                   '    - 1\n'
-                   '    - 2\n'
-                   '    - 3\n'
-                   'list two:\n'
-                   '- a\n'
-                   '- b\n'
-                   '- c\n', conf, problem1=(7, 1))
-        self.check('---\n'
-                   'list one:\n'
-                   '- 1\n'
-                   '- 2\n'
-                   '- 3\n'
-                   'list two:\n'
-                   '- a\n'
-                   '- b\n'
-                   '- c\n', conf)
-        self.check('---\n'
-                   'list one:\n'
-                   '  - 1\n'
-                   '  - 2\n'
-                   '  - 3\n'
-                   'list two:\n'
-                   '    - a\n'
-                   '    - b\n'
-                   '    - c\n', conf, problem1=(7, 5))
-
-        conf = 'indentation: {spaces: consistent, indent-sequences: whatever}'
-        self.check('---\n'
-                   'list one:\n'
-                   '- 1\n'
-                   '- 2\n'
-                   '- 3\n'
-                   'list two:\n'
-                   '    - a\n'
-                   '    - b\n'
-                   '    - c\n', conf)
-        self.check('---\n'
-                   'list one:\n'
-                   '    - 1\n'
-                   '    - 2\n'
-                   '    - 3\n'
-                   'list two:\n'
-                   '- a\n'
-                   '- b\n'
-                   '- c\n', conf)
-        self.check('---\n'
-                   'list one:\n'
-                   '- 1\n'
-                   '- 2\n'
-                   '- 3\n'
-                   'list two:\n'
-                   '- a\n'
-                   '- b\n'
-                   '- c\n', conf)
-        self.check('---\n'
-                   'list one:\n'
-                   '  - 1\n'
-                   '  - 2\n'
-                   '  - 3\n'
-                   'list two:\n'
-                   '    - a\n'
-                   '    - b\n'
-                   '    - c\n', conf, problem1=(7, 5))
-
     def test_indent_sequences_whatever(self):
         conf = 'indentation: {spaces: 4, indent-sequences: whatever}'
         self.check('---\n'
@@ -1211,20 +1071,6 @@ class IndentationTestCase(RuleTestCase):
                    '        - name: Linux\n'
                    '         date: 1991\n'
                    '...\n', conf, problem=(5, 10, 'syntax'))
-        conf = 'indentation: {spaces: 2, indent-sequences: true}'
-        self.check('---\n'
-                   'a:\n'
-                   '-\n'  # empty list
-                   'b: c\n'
-                   '...\n', conf, problem=(3, 1))
-        conf = 'indentation: {spaces: 2, indent-sequences: consistent}'
-        self.check('---\n'
-                   'a:\n'
-                   '  -\n'  # empty list
-                   'b:\n'
-                   '-\n'
-                   'c: d\n'
-                   '...\n', conf, problem=(5, 1))
 
     def test_over_indented(self):
         conf = 'indentation: {spaces: 2, indent-sequences: consistent}'
@@ -1281,23 +1127,9 @@ class IndentationTestCase(RuleTestCase):
                    '    - subel\n'
                    '...\n', conf,
                    problem=(2, 3))
-        conf = 'indentation: {spaces: 2, indent-sequences: false}'
-        self.check('---\n'
-                   'a:\n'
-                   '  -\n'  # empty list
-                   'b: c\n'
-                   '...\n', conf, problem=(3, 3))
-        conf = 'indentation: {spaces: 2, indent-sequences: consistent}'
-        self.check('---\n'
-                   'a:\n'
-                   '-\n'  # empty list
-                   'b:\n'
-                   '  -\n'
-                   'c: d\n'
-                   '...\n', conf, problem=(5, 3))
 
     def test_multi_lines(self):
-        conf = 'indentation: {spaces: consistent, indent-sequences: true}'
+        conf = 'indentation: {spaces: consistent, indent-sequences: yes}'
         self.check('---\n'
                    'long_string: >\n'
                    '  bla bla blah\n'
@@ -1370,45 +1202,6 @@ class IndentationTestCase(RuleTestCase):
                    '               key: value\n'
                    '...\n', conf, problem=(2, 2))
 
-    def test_nested_collections_with_spaces_consistent(self):
-        """Tests behavior of {spaces: consistent} in nested collections to
-        ensure wrong-indentation is properly caught--especially when the
-        expected indent value is initially unknown. For details, see
-        https://github.com/adrienverge/yamllint/issues/485.
-        """
-        conf = ('indentation: {spaces: consistent,\n'
-                '              indent-sequences: true}')
-        self.check('---\n'
-                   '- item:\n'
-                   '  - elem\n'
-                   '- item:\n'
-                   '    - elem\n'
-                   '...\n', conf, problem=(3, 3))
-        conf = ('indentation: {spaces: consistent,\n'
-                '              indent-sequences: false}')
-        self.check('---\n'
-                   '- item:\n'
-                   '  - elem\n'
-                   '- item:\n'
-                   '    - elem\n'
-                   '...\n', conf, problem=(5, 5))
-        conf = ('indentation: {spaces: consistent,\n'
-                '              indent-sequences: consistent}')
-        self.check('---\n'
-                   '- item:\n'
-                   '  - elem\n'
-                   '- item:\n'
-                   '    - elem\n'
-                   '...\n', conf, problem=(5, 5))
-        conf = ('indentation: {spaces: consistent,\n'
-                '              indent-sequences: whatever}')
-        self.check('---\n'
-                   '- item:\n'
-                   '  - elem\n'
-                   '- item:\n'
-                   '    - elem\n'
-                   '...\n', conf)
-
     def test_return(self):
         conf = 'indentation: {spaces: consistent}'
         self.check('---\n'
@@ -1644,7 +1437,7 @@ class IndentationTestCase(RuleTestCase):
                    '- !!map  # Block collection\n'
                    '  foo: bar\n', conf)
 
-        conf = 'indentation: {spaces: consistent, indent-sequences: false}'
+        conf = 'indentation: {spaces: consistent, indent-sequences: no}'
         self.check('---\n'
                    'sequence: !!seq\n'
                    '- entry\n'
@@ -1711,7 +1504,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_basics_plain(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: false}\n'
+                '              check-multi-line-strings: no}\n'
                 'document-start: disable\n')
         self.check('multi\n'
                    'line\n', conf)
@@ -1740,7 +1533,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_check_multi_line_plain(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: true}\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('multi\n'
                    ' line\n', conf, problem=(2, 2))
@@ -1763,7 +1556,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_basics_quoted(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: false}\n'
+                '              check-multi-line-strings: no}\n'
                 'document-start: disable\n')
         self.check('"multi\n'
                    ' line"\n', conf)
@@ -1794,7 +1587,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_check_multi_line_quoted(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: true}\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('"multi\n'
                    'line"\n', conf, problem=(2, 1))
@@ -1850,7 +1643,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_basics_folded_style(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: false}\n'
+                '              check-multi-line-strings: no}\n'
                 'document-start: disable\n')
         self.check('>\n'
                    '  multi\n'
@@ -1888,7 +1681,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_check_multi_line_folded_style(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: true}\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('>\n'
                    '  multi\n'
@@ -1929,7 +1722,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_basics_literal_style(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: false}\n'
+                '              check-multi-line-strings: no}\n'
                 'document-start: disable\n')
         self.check('|\n'
                    '  multi\n'
@@ -1967,7 +1760,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_check_multi_line_literal_style(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: true}\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('|\n'
                    '  multi\n'
@@ -2011,7 +1804,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_paragraph_plain(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: true}\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('- long text: very "long"\n'
                    '             \'string\' with\n'
@@ -2033,7 +1826,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_paragraph_double_quoted(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: true}\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('- long text: "very \\"long\\"\n'
                    '              \'string\' with\n'
@@ -2061,7 +1854,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_paragraph_single_quoted(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: true}\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('- long text: \'very "long"\n'
                    '              \'\'string\'\' with\n'
@@ -2089,7 +1882,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_paragraph_folded(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: true}\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('- long text: >\n'
                    '    very "long"\n'
@@ -2107,7 +1900,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_paragraph_literal(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: true}\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('- long text: |\n'
                    '    very "long"\n'
@@ -2125,7 +1918,7 @@ class ScalarIndentationTestCase(RuleTestCase):
 
     def test_consistent(self):
         conf = ('indentation: {spaces: consistent,\n'
-                '              check-multi-line-strings: true}\n'
+                '              check-multi-line-strings: yes}\n'
                 'document-start: disable\n')
         self.check('multi\n'
                    'line\n', conf)

tests/rules/test_key_duplicates.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -77,19 +78,6 @@ 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)
-        self.check('---\n'
-                   '{a: 1, b: 2}}\n', conf, problem=(2, 13, 'syntax'))
-        self.check('---\n'
-                   '[a, b, c]]\n', conf, problem=(2, 10, 'syntax'))
 
     def test_enabled(self):
         conf = 'key-duplicates: enable'
@@ -159,19 +147,6 @@ 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)
-        self.check('---\n'
-                   '{a: 1, b: 2}}\n', conf, problem=(2, 13, 'syntax'))
-        self.check('---\n'
-                   '[a, b, c]]\n', conf, problem=(2, 10, 'syntax'))
 
     def test_key_tokens_in_flow_sequences(self):
         conf = 'key-duplicates: enable'

tests/rules/test_key_ordering.py

@@ -1,149 +0,0 @@
-# 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/>.
-
-import locale
-
-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))
-
-    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)
-
-    def test_locale_case(self):
-        self.addCleanup(locale.setlocale, locale.LC_ALL, (None, None))
-        try:
-            locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
-        except locale.Error:  # pragma: no cover
-            self.skipTest('locale en_US.UTF-8 not available')
-        conf = ('key-ordering: enable')
-        self.check('---\n'
-                   't-shirt: 1\n'
-                   'T-shirt: 2\n'
-                   't-shirts: 3\n'
-                   'T-shirts: 4\n', conf)
-        self.check('---\n'
-                   't-shirt: 1\n'
-                   't-shirts: 2\n'
-                   'T-shirt: 3\n'
-                   'T-shirts: 4\n', conf,
-                   problem=(4, 1))
-
-    def test_locale_accents(self):
-        self.addCleanup(locale.setlocale, locale.LC_ALL, (None, None))
-        try:
-            locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
-        except locale.Error:  # pragma: no cover
-            self.skipTest('locale en_US.UTF-8 not available')
-        conf = ('key-ordering: enable')
-        self.check('---\n'
-                   'hair: true\n'
-                   'haïr: true\n'
-                   'hais: true\n'
-                   'haïssable: true\n', conf)
-        self.check('---\n'
-                   'hais: true\n'
-                   'haïr: true\n', conf,
-                   problem=(3, 1))

tests/rules/test_line_length.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -31,9 +32,6 @@ 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'
@@ -65,7 +63,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: true}'
+        conf = 'line-length: {max: 20, allow-non-breakable-words: yes}'
         self.check('---\n' + 30 * 'A' + '\n', conf)
         self.check('---\n'
                    'this:\n'
@@ -80,17 +78,8 @@ 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: false}'
+        conf = 'line-length: {max: 20, allow-non-breakable-words: no}'
         self.check('---\n' + 30 * 'A' + '\n', conf, problem=(2, 21))
         self.check('---\n'
                    'this:\n'
@@ -105,94 +94,3 @@ 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}'
-        self.check('---\n'
-                   '# http://www.verylongurlurlurlurlurlurlurlurl.com\n'
-                   'key:\n'
-                   '  subkey: value\n', conf)
-        self.check('---\n'
-                   '## http://www.verylongurlurlurlurlurlurlurlurl.com\n'
-                   'key:\n'
-                   '  subkey: value\n', conf)
-        self.check('---\n'
-                   '# # http://www.verylongurlurlurlurlurlurlurlurl.com\n'
-                   'key:\n'
-                   '  subkey: value\n', conf,
-                   problem=(2, 21))
-        self.check('---\n'
-                   '#A http://www.verylongurlurlurlurlurlurlurlurl.com\n'
-                   'key:\n'
-                   '  subkey: value\n', conf,
-                   problem1=(2, 2, 'comments'),
-                   problem2=(2, 21, 'line-length'))
-
-        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))
-
-    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 across bytes! ↺\n',
-                   conf)
-        conf = 'line-length: {max: 51}'
-        self.check('---\n'
-                   '# This is a test to check if “line-length” works nice\n'
-                   'with: “unicode characters” that span across bytes! ↺\n',
-                   conf, problem1=(2, 52), problem2=(3, 52))
-
-    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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify

tests/rules/test_new_lines.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -13,8 +14,6 @@
 # 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 unittest import mock
-
 from tests.common import RuleTestCase
 
 
@@ -32,65 +31,17 @@ class NewLinesTestCase(RuleTestCase):
         self.check('---\r\ntext\r\n', conf)
 
     def test_unix_type(self):
-        conf = ('new-line-at-end-of-file: disable\n'
+        conf = 'new-lines: {type: unix}'
-                '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_unix_type_required_st_sp(self):
-        # If we find a CRLF when looking for Unix newlines, yamllint
-        # should always raise, regardless of logic with
-        # require-starting-space.
-        conf = ('new-line-at-end-of-file: disable\n'
-                'new-lines: {type: unix}\n'
-                'comments:\n'
-                '  require-starting-space: true\n')
-        self.check('---\r\n#\r\n', conf, problem=(1, 4))
-
     def test_dos_type(self):
-        conf = ('new-line-at-end-of-file: disable\n'
+        conf = 'new-lines: {type: dos}\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))
         self.check('---\r\ntext\r\n', conf)
-
-    def test_platform_type(self):
-        conf = ('new-line-at-end-of-file: disable\n'
-                'new-lines: {type: platform}\n')
-
-        self.check('', conf)
-
-        # mock the Linux new-line-character
-        with mock.patch('yamllint.rules.new_lines.linesep', '\n'):
-            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))
-            self.check('---\r\ntext\n', conf, problem=(1, 4))
-            # FIXME: the following tests currently don't work
-            # because only the first line is checked for line-endings
-            # see: issue #475
-            # ---
-            # self.check('---\ntext\r\nfoo\n', conf, problem=(2, 4))
-            # self.check('---\ntext\r\n', conf, problem=(2, 4))
-
-        # mock the Windows new-line-character
-        with mock.patch('yamllint.rules.new_lines.linesep', '\r\n'):
-            self.check('\r\n', conf)
-            self.check('\n', conf, problem=(1, 1))
-            self.check('---\r\ntext\r\n', conf)
-            self.check('---\ntext\n', conf, problem=(1, 4))
-            self.check('---\ntext\r\n', conf, problem=(1, 4))
-            # FIXME: the following tests currently don't work
-            # because only the first line is checked for line-endings
-            # see: issue #475
-            # ---
-            # self.check('---\r\ntext\nfoo\r\n', conf, problem=(2, 4))
-            # self.check('---\r\ntext\n', conf, problem=(2, 4))

tests/rules/test_octal_values.py

@@ -1,80 +0,0 @@
-# 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('after-tag: !custom_tag 010', conf)
-        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)
-        self.check('with-decimal-digits: 012345678', conf)
-        self.check('with-decimal-digits: 012345679', 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)
-        self.check('with-decimal-digits: 0o012345678', conf)
-        self.check('with-decimal-digits: 0o012345679', conf)

tests/rules/test_quoted_strings.py

@@ -1,558 +0,0 @@
-# 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
-
-from yamllint import config
-
-
-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'
-                   '- \'foo # bar\'\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))
-
-    def test_only_when_needed_extras(self):
-        conf = ('quoted-strings:\n'
-                '  required: true\n'
-                '  extra-allowed: [^http://]\n')
-        self.assertRaises(config.YamlLintConfigError, self.check, '', conf)
-
-        conf = ('quoted-strings:\n'
-                '  required: true\n'
-                '  extra-required: [^http://]\n')
-        self.assertRaises(config.YamlLintConfigError, self.check, '', conf)
-
-        conf = ('quoted-strings:\n'
-                '  required: false\n'
-                '  extra-allowed: [^http://]\n')
-        self.assertRaises(config.YamlLintConfigError, self.check, '', conf)
-
-        conf = ('quoted-strings:\n'
-                '  required: true\n')
-        self.check('---\n'
-                   '- 123\n'
-                   '- "123"\n'
-                   '- localhost\n'                  # fails
-                   '- "localhost"\n'
-                   '- http://localhost\n'           # fails
-                   '- "http://localhost"\n'
-                   '- ftp://localhost\n'            # fails
-                   '- "ftp://localhost"\n',
-                   conf, problem1=(4, 3), problem2=(6, 3), problem3=(8, 3))
-
-        conf = ('quoted-strings:\n'
-                '  required: only-when-needed\n'
-                '  extra-allowed: [^ftp://]\n'
-                '  extra-required: [^http://]\n')
-        self.check('---\n'
-                   '- 123\n'
-                   '- "123"\n'
-                   '- localhost\n'
-                   '- "localhost"\n'                # fails
-                   '- http://localhost\n'           # fails
-                   '- "http://localhost"\n'
-                   '- ftp://localhost\n'
-                   '- "ftp://localhost"\n',
-                   conf, problem1=(5, 3), problem2=(6, 3))
-
-        conf = ('quoted-strings:\n'
-                '  required: false\n'
-                '  extra-required: [^http://, ^ftp://]\n')
-        self.check('---\n'
-                   '- 123\n'
-                   '- "123"\n'
-                   '- localhost\n'
-                   '- "localhost"\n'
-                   '- http://localhost\n'           # fails
-                   '- "http://localhost"\n'
-                   '- ftp://localhost\n'            # fails
-                   '- "ftp://localhost"\n',
-                   conf, problem1=(6, 3), problem2=(8, 3))
-
-        conf = ('quoted-strings:\n'
-                '  required: only-when-needed\n'
-                '  extra-allowed: [^ftp://, ";$", " "]\n')
-        self.check('---\n'
-                   '- localhost\n'
-                   '- "localhost"\n'                # fails
-                   '- ftp://localhost\n'
-                   '- "ftp://localhost"\n'
-                   '- i=i+1\n'
-                   '- "i=i+1"\n'                # fails
-                   '- i=i+2;\n'
-                   '- "i=i+2;"\n'
-                   '- foo\n'
-                   '- "foo"\n'                      # fails
-                   '- foo bar\n'
-                   '- "foo bar"\n',
-                   conf, problem1=(3, 3), problem2=(7, 3), problem3=(11, 3))
-
-    def test_octal_values(self):
-        conf = 'quoted-strings: {required: true}\n'
-
-        self.check('---\n'
-                   '- 100\n'
-                   '- 0100\n'
-                   '- 0o100\n'
-                   '- 777\n'
-                   '- 0777\n'
-                   '- 0o777\n'
-                   '- 800\n'
-                   '- 0800\n'
-                   '- 0o800\n'
-                   '- "0800"\n'
-                   '- "0o800"\n',
-                   conf,
-                   problem1=(9, 3), problem2=(10, 3))
-
-    def test_allow_quoted_quotes(self):
-        conf = ('quoted-strings: {quote-type: single,\n'
-                '                 required: false,\n'
-                '                 allow-quoted-quotes: false}\n')
-        self.check('---\n'
-                   'foo1: "[barbaz]"\n'          # fails
-                   'foo2: "[bar\'baz]"\n',       # fails
-                   conf, problem1=(2, 7), problem2=(3, 7))
-
-        conf = ('quoted-strings: {quote-type: single,\n'
-                '                 required: false,\n'
-                '                 allow-quoted-quotes: true}\n')
-        self.check('---\n'
-                   'foo1: "[barbaz]"\n'          # fails
-                   'foo2: "[bar\'baz]"\n',
-                   conf, problem1=(2, 7))
-
-        conf = ('quoted-strings: {quote-type: single,\n'
-                '                 required: true,\n'
-                '                 allow-quoted-quotes: false}\n')
-        self.check('---\n'
-                   'foo1: "[barbaz]"\n'          # fails
-                   'foo2: "[bar\'baz]"\n',       # fails
-                   conf, problem1=(2, 7), problem2=(3, 7))
-
-        conf = ('quoted-strings: {quote-type: single,\n'
-                '                 required: true,\n'
-                '                 allow-quoted-quotes: true}\n')
-        self.check('---\n'
-                   'foo1: "[barbaz]"\n'          # fails
-                   'foo2: "[bar\'baz]"\n',
-                   conf, problem1=(2, 7))
-
-        conf = ('quoted-strings: {quote-type: single,\n'
-                '                 required: only-when-needed,\n'
-                '                 allow-quoted-quotes: false}\n')
-        self.check('---\n'
-                   'foo1: "[barbaz]"\n'          # fails
-                   'foo2: "[bar\'baz]"\n',       # fails
-                   conf, problem1=(2, 7), problem2=(3, 7))
-
-        conf = ('quoted-strings: {quote-type: single,\n'
-                '                 required: only-when-needed,\n'
-                '                 allow-quoted-quotes: true}\n')
-        self.check('---\n'
-                   'foo1: "[barbaz]"\n'          # fails
-                   'foo2: "[bar\'baz]"\n',
-                   conf, problem1=(2, 7))
-
-        conf = ('quoted-strings: {quote-type: double,\n'
-                '                 required: false,\n'
-                '                 allow-quoted-quotes: false}\n')
-        self.check("---\n"
-                   "foo1: '[barbaz]'\n"          # fails
-                   "foo2: '[bar\"baz]'\n",       # fails
-                   conf, problem1=(2, 7), problem2=(3, 7))
-
-        conf = ('quoted-strings: {quote-type: double,\n'
-                '                 required: false,\n'
-                '                 allow-quoted-quotes: true}\n')
-        self.check("---\n"
-                   "foo1: '[barbaz]'\n"          # fails
-                   "foo2: '[bar\"baz]'\n",
-                   conf, problem1=(2, 7))
-
-        conf = ('quoted-strings: {quote-type: double,\n'
-                '                 required: true,\n'
-                '                 allow-quoted-quotes: false}\n')
-        self.check("---\n"
-                   "foo1: '[barbaz]'\n"          # fails
-                   "foo2: '[bar\"baz]'\n",       # fails
-                   conf, problem1=(2, 7), problem2=(3, 7))
-
-        conf = ('quoted-strings: {quote-type: double,\n'
-                '                 required: true,\n'
-                '                 allow-quoted-quotes: true}\n')
-        self.check("---\n"
-                   "foo1: '[barbaz]'\n"          # fails
-                   "foo2: '[bar\"baz]'\n",
-                   conf, problem1=(2, 7))
-
-        conf = ('quoted-strings: {quote-type: double,\n'
-                '                 required: only-when-needed,\n'
-                '                 allow-quoted-quotes: false}\n')
-        self.check("---\n"
-                   "foo1: '[barbaz]'\n"          # fails
-                   "foo2: '[bar\"baz]'\n",       # fails
-                   conf, problem1=(2, 7), problem2=(3, 7))
-
-        conf = ('quoted-strings: {quote-type: double,\n'
-                '                 required: only-when-needed,\n'
-                '                 allow-quoted-quotes: true}\n')
-        self.check("---\n"
-                   "foo1: '[barbaz]'\n"          # fails
-                   "foo2: '[bar\"baz]'\n",
-                   conf, problem1=(2, 7))
-
-        conf = ('quoted-strings: {quote-type: any}\n')
-        self.check("---\n"
-                   "foo1: '[barbaz]'\n"
-                   "foo2: '[bar\"baz]'\n",
-                   conf)

tests/rules/test_trailing_spaces.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify

tests/rules/test_truthy.py

@@ -1,145 +0,0 @@
-# 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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -13,137 +14,79 @@
 # 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 tempfile
 import unittest
-
+import sys
-from tests.common import build_temp_workspace, temp_workspace
 
 from yamllint import cli
-from yamllint import config
-
-
-class RunContext:
-    """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
-
-
-# Check system's UTF-8 availability
-def utf8_available():
-    try:
-        locale.setlocale(locale.LC_ALL, 'C.UTF-8')
-        locale.setlocale(locale.LC_ALL, (None, None))
-        return True
-    except locale.Error:  # pragma: no cover
-        return False
 
 
 class CommandLineTestCase(unittest.TestCase):
-    @classmethod
+    def setUp(self):
-    def setUpClass(cls):
+        self.wd = tempfile.mkdtemp(prefix='yamllint-tests-')
-        super(CommandLineTestCase, cls).setUpClass()
 
-        cls.wd = build_temp_workspace({
         # .yaml file at root
-            'a.yaml': '---\n'
+        with open(os.path.join(self.wd, 'a.yaml'), 'w') as f:
+            f.write('---\n'
                     '- 1   \n'
-                      '- 2',
+                    '- 2')
-            # file with only one warning
+
-            'warn.yaml': 'key: value\n',
         # .yml file at root
-            'empty.yml': '',
+        open(os.path.join(self.wd, 'empty.yml'), 'w').close()
+
         # file in dir
-            'sub/ok.yaml': '---\n'
+        os.mkdir(os.path.join(self.wd, 'sub'))
-                           'key: value\n',
+        with open(os.path.join(self.wd, 'sub', 'ok.yaml'), 'w') as f:
-            # directory that looks like a yaml file
+            f.write('---\n'
-            'sub/directory.yaml/not-yaml.txt': '',
+                    'key: value\n')
-            'sub/directory.yaml/empty.yml': '',
+
         # file in very nested dir
-            's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml': '---\n'
+        dir = self.wd
+        for i in range(15):
+            dir = os.path.join(dir, 's')
+            os.mkdir(dir)
+        with open(os.path.join(dir, 'file.yaml'), 'w') as f:
+            f.write('---\n'
                     'key: value\n'
-                                                       'key: other value\n',
+                    'key: other value\n')
+
         # empty dir
-            'empty-dir': [],
+        os.mkdir(os.path.join(self.wd, 'empty-dir'))
+
         # non-YAML file
-            'no-yaml.json': '---\n'
+        with open(os.path.join(self.wd, 'no-yaml.json'), 'w') as f:
-                            'key: value\n',
+            f.write('---\n'
-            # non-ASCII chars
+                    'key: value\n')
-            'non-ascii/éçäγλνπ¥/utf-8': (
+
-                '---\n'
+    def tearDown(self):
-                '- hétérogénéité\n'
+        shutil.rmtree(self.wd)
-                '# 19.99 €\n'
+
-                '- お早う御座います。\n'
-                '# الأَبْجَدِيَّة العَرَبِيَّة\n').encode('utf-8'),
-            # dos line endings yaml
-            'dos.yml': '---\r\n'
-                       'dos: true',
-            # different key-ordering by locale
-            'c.yaml': '---\n'
-                      'A: true\n'
-                      'a: true',
-            'en.yaml': '---\n'
-                       'a: true\n'
-                       'A: true'
-        })
-
-    @classmethod
-    def tearDownClass(cls):
-        super(CommandLineTestCase, cls).tearDownClass()
-
-        shutil.rmtree(cls.wd)
-
-    @unittest.skipIf(not utf8_available() and sys.version_info < (3, 7),
-                     'UTF-8 paths not supported')
     def test_find_files_recursively(self):
-        conf = config.YamlLintConfig('extends: default')
         self.assertEqual(
-            sorted(cli.find_files_recursively([self.wd], conf)),
+            sorted(cli.find_files_recursively([self.wd])),
             [os.path.join(self.wd, 'a.yaml'),
-             os.path.join(self.wd, 'c.yaml'),
-             os.path.join(self.wd, 'dos.yml'),
              os.path.join(self.wd, 'empty.yml'),
-             os.path.join(self.wd, 'en.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/directory.yaml/empty.yml'),
+             os.path.join(self.wd, 'sub/ok.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)),
+            sorted(cli.find_files_recursively(items)),
             [os.path.join(self.wd, 'sub/ok.yaml')],
         )
 
         items = [os.path.join(self.wd, 'empty.yml'),
                  os.path.join(self.wd, 's')]
         self.assertEqual(
-            sorted(cli.find_files_recursively(items, conf)),
+            sorted(cli.find_files_recursively(items)),
             [os.path.join(self.wd, 'empty.yml'),
              os.path.join(self.wd, 's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml')],
         )
@@ -151,371 +94,157 @@ class CommandLineTestCase(unittest.TestCase):
         items = [os.path.join(self.wd, 'sub'),
                  os.path.join(self.wd, '/etc/another/file')]
         self.assertEqual(
-            sorted(cli.find_files_recursively(items, conf)),
+            sorted(cli.find_files_recursively(items)),
             [os.path.join(self.wd, '/etc/another/file'),
-             os.path.join(self.wd, 'sub/directory.yaml/empty.yml'),
              os.path.join(self.wd, 'sub/ok.yaml')],
         )
 
-        conf = config.YamlLintConfig('extends: default\n'
+    def test_run_with_bad_arguments(self):
-                                     'yaml-files:\n'
+        sys.stdout, sys.stderr = StringIO(), StringIO()
-                                     '  - \'*.yaml\' \n')
+        with self.assertRaises(SystemExit) as ctx:
-        self.assertEqual(
+            cli.run(())
-            sorted(cli.find_files_recursively([self.wd], conf)),
-            [os.path.join(self.wd, 'a.yaml'),
-             os.path.join(self.wd, 'c.yaml'),
-             os.path.join(self.wd, 'en.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'),
-             os.path.join(self.wd, 'sub/directory.yaml/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'
+        self.assertNotEqual(ctx.exception.code, 0)
-                                     '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, 'c.yaml'),
-             os.path.join(self.wd, 'dos.yml'),
-             os.path.join(self.wd, 'empty.yml'),
-             os.path.join(self.wd, 'en.yaml'),
-             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/directory.yaml/empty.yml'),
-             os.path.join(self.wd, 'sub/directory.yaml/not-yaml.txt'),
-             os.path.join(self.wd, 'sub/ok.yaml'),
-             os.path.join(self.wd, 'warn.yaml')]
-        )
 
-        conf = config.YamlLintConfig('extends: default\n'
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-                                     'yaml-files:\n'
+        self.assertEqual(out, '')
-                                     '  - \'*.yaml\'\n'
+        self.assertRegexpMatches(err, r'^usage')
-                                     '  - \'*\'\n'
-                                     '  - \'**\'\n')
-        self.assertEqual(
-            sorted(cli.find_files_recursively([self.wd], conf)),
-            [os.path.join(self.wd, 'a.yaml'),
-             os.path.join(self.wd, 'c.yaml'),
-             os.path.join(self.wd, 'dos.yml'),
-             os.path.join(self.wd, 'empty.yml'),
-             os.path.join(self.wd, 'en.yaml'),
-             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/directory.yaml/empty.yml'),
-             os.path.join(self.wd, 'sub/directory.yaml/not-yaml.txt'),
-             os.path.join(self.wd, 'sub/ok.yaml'),
-             os.path.join(self.wd, 'warn.yaml')]
-        )
 
-        conf = config.YamlLintConfig('extends: default\n'
+        sys.stdout, sys.stderr = StringIO(), StringIO()
-                                     'yaml-files:\n'
+        with self.assertRaises(SystemExit) as ctx:
-                                     '  - \'s/**\'\n'
+            cli.run(('--unknown-arg', ))
-                                     '  - \'**/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):
+        self.assertNotEqual(ctx.exception.code, 0)
-        with RunContext(self) as ctx:
-            cli.run(())
-        self.assertNotEqual(ctx.returncode, 0)
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(ctx.stderr, r'^usage')
 
-        with RunContext(self) as ctx:
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-            cli.run(('--unknown-arg', ))
+        self.assertEqual(out, '')
-        self.assertNotEqual(ctx.returncode, 0)
+        self.assertRegexpMatches(err, r'^usage')
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(ctx.stderr, r'^usage')
 
-        with RunContext(self) as ctx:
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
             cli.run(('-c', './conf.yaml', '-d', 'relaxed', 'file'))
-        self.assertNotEqual(ctx.returncode, 0)
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(
-            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
+        self.assertNotEqual(ctx.exception.code, 0)
-        with RunContext(self) as ctx:
+
-            cli.run(('-', 'file'))
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        self.assertNotEqual(ctx.returncode, 0)
+        self.assertEqual(out, '')
-        self.assertEqual(ctx.stdout, '')
+        self.assertRegexpMatches(err, r'^Options --config-file and '
-        self.assertRegex(ctx.stderr, r'^usage')
+                                      r'--config-data cannot be used')
 
     def test_run_with_bad_config(self):
-        with RunContext(self) as ctx:
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
             cli.run(('-d', 'rules: {a: b}', 'file'))
-        self.assertEqual(ctx.returncode, -1)
+
-        self.assertEqual(ctx.stdout, '')
+        self.assertEqual(ctx.exception.code, -1)
-        self.assertRegex(ctx.stderr, r'^invalid config: no such rule')
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, '')
+        self.assertRegexpMatches(err, r'^invalid config: no such rule')
 
     def test_run_with_empty_config(self):
-        with RunContext(self) as ctx:
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
             cli.run(('-d', '', 'file'))
-        self.assertEqual(ctx.returncode, -1)
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(ctx.stderr, r'^invalid config: not a dict')
 
-    def test_run_with_implicit_extends_config(self):
+        self.assertEqual(ctx.exception.code, -1)
-        path = os.path.join(self.wd, 'warn.yaml')
 
-        with RunContext(self) as ctx:
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-            cli.run(('-d', 'default', '-f', 'parsable', path))
+        self.assertEqual(out, '')
-        expected_out = ('%s:1:1: [warning] missing document start "---" '
+        self.assertRegexpMatches(err, r'^invalid config: not a dict')
-                        '(document-start)\n' % path)
-        self.assertEqual(
-            (ctx.returncode, ctx.stdout, ctx.stderr), (0, expected_out, ''))
-
-    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)
-
-    @unittest.skipIf(os.environ.get('GITHUB_RUN_ID'), '$HOME not overridable')
-    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_with_user_xdg_config_home_in_env(self):
-        self.addCleanup(os.environ.__delitem__, 'XDG_CONFIG_HOME')
-
-        with tempfile.TemporaryDirectory('w') as d:
-            os.environ['XDG_CONFIG_HOME'] = d
-            os.makedirs(os.path.join(d, 'yamllint'))
-            with open(os.path.join(d, 'yamllint', 'config'), 'w') as f:
-                f.write('extends: relaxed')
-            with RunContext(self) as ctx:
-                cli.run(('-f', 'parsable', os.path.join(self.wd, 'warn.yaml')))
-
-        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
-
-    def test_run_with_user_yamllint_config_file_in_env(self):
-        self.addCleanup(os.environ.__delitem__, 'YAMLLINT_CONFIG_FILE')
-
-        with tempfile.NamedTemporaryFile('w') as f:
-            os.environ['YAMLLINT_CONFIG_FILE'] = f.name
-            f.write('rules: {trailing-spaces: disable}')
-            f.flush()
-            with RunContext(self) as ctx:
-                cli.run((os.path.join(self.wd, 'a.yaml'), ))
-            self.assertEqual(ctx.returncode, 0)
-
-        with tempfile.NamedTemporaryFile('w') as f:
-            os.environ['YAMLLINT_CONFIG_FILE'] = f.name
-            f.write('rules: {trailing-spaces: enable}')
-            f.flush()
-            with RunContext(self) as ctx:
-                cli.run((os.path.join(self.wd, 'a.yaml'), ))
-            self.assertEqual(ctx.returncode, 1)
-
-    def test_run_with_locale(self):
-        # check for availability of locale, otherwise skip the test
-        # reset to default before running the test,
-        # as the first two runs don't use setlocale()
-        try:
-            locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
-        except locale.Error:  # pragma: no cover
-            self.skipTest('locale en_US.UTF-8 not available')
-        locale.setlocale(locale.LC_ALL, (None, None))
-
-        # C + en.yaml should fail
-        with RunContext(self) as ctx:
-            cli.run(('-d', 'rules: { key-ordering: enable }',
-                     os.path.join(self.wd, 'en.yaml')))
-        self.assertEqual(ctx.returncode, 1)
-
-        # C + c.yaml should pass
-        with RunContext(self) as ctx:
-            cli.run(('-d', 'rules: { key-ordering: enable }',
-                    os.path.join(self.wd, 'c.yaml')))
-        self.assertEqual(ctx.returncode, 0)
-
-        # the next two runs use setlocale() inside,
-        # so we need to clean up afterwards
-        self.addCleanup(locale.setlocale, locale.LC_ALL, (None, None))
-
-        # en_US + en.yaml should pass
-        with RunContext(self) as ctx:
-            cli.run(('-d', 'locale: en_US.UTF-8\n'
-                           'rules: { key-ordering: enable }',
-                     os.path.join(self.wd, 'en.yaml')))
-        self.assertEqual(ctx.returncode, 0)
-
-        # en_US + c.yaml should fail
-        with RunContext(self) as ctx:
-            cli.run(('-d', 'locale: en_US.UTF-8\n'
-                           'rules: { key-ordering: enable }',
-                     os.path.join(self.wd, 'c.yaml')))
-        self.assertEqual(ctx.returncode, 1)
 
     def test_run_version(self):
-        with RunContext(self) as ctx:
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
             cli.run(('--version', ))
-        self.assertEqual(ctx.returncode, 0)
+
-        self.assertRegex(ctx.stdout + ctx.stderr, r'yamllint \d+\.\d+')
+        self.assertEqual(ctx.exception.code, 0)
+
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertRegexpMatches(out + err, r'yamllint \d+\.\d+')
 
     def test_run_non_existing_file(self):
-        path = os.path.join(self.wd, 'i-do-not-exist.yaml')
+        file = os.path.join(self.wd, 'i-do-not-exist.yaml')
 
-        with RunContext(self) as ctx:
+        sys.stdout, sys.stderr = StringIO(), StringIO()
-            cli.run(('-f', 'parsable', path))
+        with self.assertRaises(SystemExit) as ctx:
-        self.assertEqual(ctx.returncode, -1)
+            cli.run(('-f', 'parsable', file))
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(ctx.stderr, r'No such file or directory')
 
-    def test_run_one_problem_file(self):
+        self.assertEqual(ctx.exception.code, -1)
-        path = os.path.join(self.wd, 'a.yaml')
 
-        with RunContext(self) as ctx:
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-            cli.run(('-f', 'parsable', path))
+        self.assertEqual(out, '')
-        self.assertEqual(ctx.returncode, 1)
+        self.assertRegexpMatches(err, r'No such file or directory')
-        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):
+    def test_run_one_problem_file(self):
-        path = os.path.join(self.wd, 'warn.yaml')
+        file = os.path.join(self.wd, 'a.yaml')
 
-        with RunContext(self) as ctx:
+        sys.stdout, sys.stderr = StringIO(), StringIO()
-            cli.run(('-f', 'parsable', path))
+        with self.assertRaises(SystemExit) as ctx:
-        self.assertEqual(ctx.returncode, 0)
+            cli.run(('-f', 'parsable', file))
 
-    def test_run_warning_in_strict_mode(self):
+        self.assertEqual(ctx.exception.code, 1)
-        path = os.path.join(self.wd, 'warn.yaml')
 
-        with RunContext(self) as ctx:
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-            cli.run(('-f', 'parsable', '--strict', path))
+        self.assertEqual(out, (
-        self.assertEqual(ctx.returncode, 2)
+            '%s:2:4: [error] trailing spaces (trailing-spaces)\n'
+            '%s:3:4: [error] no new line character at the end of file '
+            '(new-line-at-end-of-file)\n') % (file, file))
+        self.assertEqual(err, '')
 
     def test_run_one_ok_file(self):
-        path = os.path.join(self.wd, 'sub', 'ok.yaml')
+        file = os.path.join(self.wd, 'sub', 'ok.yaml')
+
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) as ctx:
+            cli.run(('-f', 'parsable', file))
 
-        with RunContext(self) as ctx:
+        self.assertEqual(ctx.exception.code, 0)
-            cli.run(('-f', 'parsable', path))
+
-        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
+        self.assertEqual(out, '')
+        self.assertEqual(err, '')
 
     def test_run_empty_file(self):
-        path = os.path.join(self.wd, 'empty.yml')
+        file = os.path.join(self.wd, 'empty.yml')
 
-        with RunContext(self) as ctx:
+        sys.stdout, sys.stderr = StringIO(), StringIO()
-            cli.run(('-f', 'parsable', path))
+        with self.assertRaises(SystemExit) as ctx:
-        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
+            cli.run(('-f', 'parsable', file))
 
-    @unittest.skipIf(not utf8_available(), 'C.UTF-8 not available')
+        self.assertEqual(ctx.exception.code, 0)
-    def test_run_non_ascii_file(self):
-        locale.setlocale(locale.LC_ALL, 'C.UTF-8')
-        self.addCleanup(locale.setlocale, locale.LC_ALL, (None, None))
 
-        path = os.path.join(self.wd, 'non-ascii', 'éçäγλνπ¥', 'utf-8')
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        with RunContext(self) as ctx:
+        self.assertEqual(out, '')
-            cli.run(('-f', 'parsable', path))
+        self.assertEqual(err, '')
-        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'
+        file = items[1] + '/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'
 
-        with RunContext(self) as ctx:
+        sys.stdout, sys.stderr = StringIO(), StringIO()
+        with self.assertRaises(SystemExit) 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):
+        self.assertEqual(ctx.exception.code, 1)
-        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):
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        path = os.path.join(self.wd, 'a.yaml')
+        self.assertEqual(out, (
+            '%s:3:1: [error] duplication of key "key" in mapping '
+            '(key-duplicates)\n') % file)
+        self.assertEqual(err, '')
 
-        # Create a pseudo-TTY and redirect stdout to it
+    def test_run_colored_output(self):
-        master, slave = pty.openpty()
+        file = os.path.join(self.wd, 'a.yaml')
-        sys.stdout = sys.stderr = os.fdopen(slave, 'w')
 
+        sys.stdout, sys.stderr = StringIO(), StringIO()
         with self.assertRaises(SystemExit) as ctx:
-            cli.run((path, ))
+            cli.run((file, ))
-        sys.stdout.flush()
 
         self.assertEqual(ctx.exception.code, 1)
 
-        # Read output from TTY
+        out, err = sys.stdout.getvalue(), sys.stderr.getvalue()
-        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    '
@@ -523,275 +252,5 @@ class CommandLineTestCase(unittest.TestCase):
             '  \033[2m3:4\033[0m       \033[31merror\033[0m    '
             'no new line character at the end of file  '
             '\033[2m(new-line-at-end-of-file)\033[0m\n'
-            '\n' % path))
+            '\n' % file))
-
+        self.assertEqual(err, '')
-    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_format_colored_warning(self):
-        path = os.path.join(self.wd, 'warn.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run((path, '--format', 'colored'))
-        expected_out = (
-            '\033[4m%s\033[0m\n'
-            '  \033[2m1:1\033[0m       \033[33mwarning\033[0m  '
-            'missing document start "---"  \033[2m(document-start)\033[0m\n'
-            '\n' % path)
-        self.assertEqual(
-            (ctx.returncode, ctx.stdout, ctx.stderr), (0, expected_out, ''))
-
-    def test_run_format_github(self):
-        path = os.path.join(self.wd, 'a.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run((path, '--format', 'github'))
-        expected_out = (
-            '::group::%s\n'
-            '::error file=%s,line=2,col=4::2:4 [trailing-spaces] trailing'
-            ' spaces\n'
-            '::error file=%s,line=3,col=4::3:4 [new-line-at-end-of-file] no'
-            ' new line character at the end of file\n'
-            '::endgroup::\n\n'
-            % (path, path, path))
-        self.assertEqual(
-            (ctx.returncode, ctx.stdout, ctx.stderr), (1, expected_out, ''))
-
-    def test_github_actions_detection(self):
-        path = os.path.join(self.wd, 'a.yaml')
-        self.addCleanup(os.environ.__delitem__, 'GITHUB_ACTIONS')
-        self.addCleanup(os.environ.__delitem__, 'GITHUB_WORKFLOW')
-
-        with RunContext(self) as ctx:
-            os.environ['GITHUB_ACTIONS'] = 'something'
-            os.environ['GITHUB_WORKFLOW'] = 'something'
-            cli.run((path, ))
-        expected_out = (
-            '::group::%s\n'
-            '::error file=%s,line=2,col=4::2:4 [trailing-spaces] trailing'
-            ' spaces\n'
-            '::error file=%s,line=3,col=4::3:4 [new-line-at-end-of-file] no'
-            ' new line character at the end of file\n'
-            '::endgroup::\n\n'
-            % (path, path, 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, ''))
-
-    def test_run_list_files(self):
-        with RunContext(self) as ctx:
-            cli.run(('--list-files', self.wd))
-        self.assertEqual(ctx.returncode, 0)
-        self.assertEqual(
-            sorted(ctx.stdout.splitlines()),
-            [os.path.join(self.wd, 'a.yaml'),
-             os.path.join(self.wd, 'c.yaml'),
-             os.path.join(self.wd, 'dos.yml'),
-             os.path.join(self.wd, 'empty.yml'),
-             os.path.join(self.wd, 'en.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/directory.yaml/empty.yml'),
-             os.path.join(self.wd, 'sub/ok.yaml'),
-             os.path.join(self.wd, 'warn.yaml')]
-        )
-
-        config = '{ignore: "*.yml", yaml-files: ["*.*"]}'
-        with RunContext(self) as ctx:
-            cli.run(('--list-files', '-d', config, self.wd))
-        self.assertEqual(ctx.returncode, 0)
-        self.assertEqual(
-            sorted(ctx.stdout.splitlines()),
-            [os.path.join(self.wd, 'a.yaml'),
-             os.path.join(self.wd, 'c.yaml'),
-             os.path.join(self.wd, 'en.yaml'),
-             os.path.join(self.wd, 'no-yaml.json'),
-             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/directory.yaml/not-yaml.txt'),
-             os.path.join(self.wd, 'sub/ok.yaml'),
-             os.path.join(self.wd, 'warn.yaml')]
-        )
-
-
-class CommandLineConfigTestCase(unittest.TestCase):
-    def test_config_file(self):
-        workspace = {'a.yml': 'hello: world\n'}
-        conf = ('---\n'
-                'extends: relaxed\n')
-
-        for conf_file in ('.yamllint', '.yamllint.yml', '.yamllint.yaml'):
-            with self.subTest(conf_file):
-                with temp_workspace(workspace):
-                    with RunContext(self) as ctx:
-                        cli.run(('-f', 'parsable', '.'))
-
-                self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr),
-                                 (0, './a.yml:1:1: [warning] missing document '
-                                     'start "---" (document-start)\n', ''))
-
-                with temp_workspace({**workspace, **{conf_file: conf}}):
-                    with RunContext(self) as ctx:
-                        cli.run(('-f', 'parsable', '.'))
-
-                self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr),
-                                 (0, '', ''))
-
-    def test_parent_config_file(self):
-        workspace = {'a/b/c/d/e/f/g/a.yml': 'hello: world\n'}
-        conf = ('---\n'
-                'extends: relaxed\n')
-
-        for conf_file in ('.yamllint', '.yamllint.yml', '.yamllint.yaml'):
-            with self.subTest(conf_file):
-                with temp_workspace(workspace):
-                    with RunContext(self) as ctx:
-                        os.chdir('a/b/c/d/e/f')
-                        cli.run(('-f', 'parsable', '.'))
-
-                self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr),
-                                 (0, './g/a.yml:1:1: [warning] missing '
-                                     'document start "---" (document-start)\n',
-                                     ''))
-
-                with temp_workspace({**workspace, **{conf_file: conf}}):
-                    with RunContext(self) as ctx:
-                        os.chdir('a/b/c/d/e/f')
-                        cli.run(('-f', 'parsable', '.'))
-
-                self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr),
-                                 (0, '', ''))
-
-    def test_multiple_parent_config_file(self):
-        workspace = {'a/b/c/3spaces.yml': 'array:\n'
-                                          '   - item\n',
-                     'a/b/c/4spaces.yml': 'array:\n'
-                                          '    - item\n',
-                     'a/.yamllint': '---\n'
-                                    'extends: relaxed\n'
-                                    'rules:\n'
-                                    '  indentation:\n'
-                                    '    spaces: 4\n',
-                     }
-
-        conf3 = ('---\n'
-                 'extends: relaxed\n'
-                 'rules:\n'
-                 '  indentation:\n'
-                 '    spaces: 3\n')
-
-        with temp_workspace(workspace):
-            with RunContext(self) as ctx:
-                os.chdir('a/b/c')
-                cli.run(('-f', 'parsable', '.'))
-
-        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr),
-                         (0, './3spaces.yml:2:4: [warning] wrong indentation: '
-                         'expected 4 but found 3 (indentation)\n', ''))
-
-        with temp_workspace({**workspace, **{'a/b/.yamllint.yml': conf3}}):
-            with RunContext(self) as ctx:
-                os.chdir('a/b/c')
-                cli.run(('-f', 'parsable', '.'))
-
-        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr),
-                         (0, './4spaces.yml:2:5: [warning] wrong indentation: '
-                         'expected 3 but found 4 (indentation)\n', ''))

tests/test_config.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -13,17 +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/>.
 
-from io import StringIO
-import os
-import shutil
-import sys
-import tempfile
 import unittest
 
-from tests.common import build_temp_workspace
-
-from yamllint.config import YamlLintConfigError
-from yamllint import cli
 from yamllint import config
 
 
@@ -38,33 +30,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(None)), 1)
+        self.assertEqual(len(new.enabled_rules()), 1)
 
     def test_invalid_conf(self):
         with self.assertRaises(config.YamlLintConfigError):
             config.YamlLintConfig('not: valid: yaml')
 
     def test_unknown_rule(self):
-        with self.assertRaisesRegex(
+        with self.assertRaisesRegexp(
                 config.YamlLintConfigError,
                 'invalid config: no such rule: "this-one-does-not-exist"'):
             config.YamlLintConfig('rules:\n'
                                   '  this-one-does-not-exist: enable\n')
 
     def test_missing_option(self):
-        c = config.YamlLintConfig('rules:\n'
+        with self.assertRaisesRegexp(
-                                  '  colons: enable\n')
+                config.YamlLintConfigError,
-        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
+                'invalid config: missing option "max-spaces-before" '
-        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
+                'for rule "colons"'):
-
+            config.YamlLintConfig('rules:\n'
-        c = config.YamlLintConfig('rules:\n'
                                   '  colons:\n'
-                                  '    max-spaces-before: 9\n')
+                                  '    max-spaces-after: 1\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.assertRaisesRegex(
+        with self.assertRaisesRegexp(
                 config.YamlLintConfigError,
                 'invalid config: unknown option "abcdef" for rule "colons"'):
             config.YamlLintConfig('rules:\n'
@@ -73,61 +62,17 @@ 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.assertRaisesRegex(
-                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:
+        class Rule(object):
             ID = 'fake'
 
-        self.assertFalse(config.validate_rule_conf(Rule, False))
+        self.assertEqual(config.validate_rule_conf(Rule, False), False)
+        self.assertEqual(config.validate_rule_conf(Rule, 'disable'), False)
+
         self.assertEqual(config.validate_rule_conf(Rule, {}),
                          {'level': 'error'})
+        self.assertEqual(config.validate_rule_conf(Rule, 'enable'),
+                         {'level': 'error'})
 
         config.validate_rule_conf(Rule, {'level': 'error'})
         config.validate_rule_conf(Rule, {'level': 'warning'})
@@ -135,22 +80,22 @@ class SimpleConfigTestCase(unittest.TestCase):
                           config.validate_rule_conf, Rule, {'level': 'warn'})
 
         Rule.CONF = {'length': int}
-        Rule.DEFAULT = {'length': 80}
         config.validate_rule_conf(Rule, {'length': 8})
-        config.validate_rule_conf(Rule, {})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {})
         self.assertRaises(config.YamlLintConfigError,
                           config.validate_rule_conf, Rule, {'height': 8})
 
         Rule.CONF = {'a': bool, 'b': int}
-        Rule.DEFAULT = {'a': True, 'b': -42}
         config.validate_rule_conf(Rule, {'a': True, 'b': 0})
-        config.validate_rule_conf(Rule, {'a': True})
+        self.assertRaises(config.YamlLintConfigError,
-        config.validate_rule_conf(Rule, {'b': 0})
+                          config.validate_rule_conf, Rule, {'a': True})
+        self.assertRaises(config.YamlLintConfigError,
+                          config.validate_rule_conf, Rule, {'b': 0})
         self.assertRaises(config.YamlLintConfigError,
                           config.validate_rule_conf, Rule, {'a': 1, 'b': 0})
 
         Rule.CONF = {'choice': (True, 88, 'str')}
-        Rule.DEFAULT = {'choice': 88}
         config.validate_rule_conf(Rule, {'choice': True})
         config.validate_rule_conf(Rule, {'choice': 88})
         config.validate_rule_conf(Rule, {'choice': 'str'})
@@ -162,72 +107,16 @@ class SimpleConfigTestCase(unittest.TestCase):
                           config.validate_rule_conf, Rule, {'choice': 'abc'})
 
         Rule.CONF = {'choice': (int, 'hardcoded')}
-        Rule.DEFAULT = {'choice': 1337}
         config.validate_rule_conf(Rule, {'choice': 42})
         config.validate_rule_conf(Rule, {'choice': 'hardcoded'})
-        config.validate_rule_conf(Rule, {})
         self.assertRaises(config.YamlLintConfigError,
                           config.validate_rule_conf, Rule, {'choice': False})
         self.assertRaises(config.YamlLintConfigError,
                           config.validate_rule_conf, Rule, {'choice': 'abc'})
 
-        Rule.CONF = {'multiple': ['item1', 'item2', 'item3']}
-        Rule.DEFAULT = {'multiple': ['item1']}
-        config.validate_rule_conf(Rule, {'multiple': []})
-        config.validate_rule_conf(Rule, {'multiple': ['item2']})
-        config.validate_rule_conf(Rule, {'multiple': ['item2', 'item3']})
-        config.validate_rule_conf(Rule, {})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule,
-                          {'multiple': 'item1'})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule,
-                          {'multiple': ['']})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule,
-                          {'multiple': ['item1', 4]})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule,
-                          {'multiple': ['item4']})
-
-    def test_invalid_rule(self):
-        with self.assertRaisesRegex(
-                config.YamlLintConfigError,
-                'invalid config: rule "colons": should be either '
-                '"enable", "disable" or a dict'):
-            config.YamlLintConfig('rules:\n'
-                                  '  colons: invalid\n')
-
-    def test_invalid_ignore(self):
-        with self.assertRaisesRegex(
-                config.YamlLintConfigError,
-                'invalid config: ignore should contain file patterns'):
-            config.YamlLintConfig('ignore: yes\n')
-
-    def test_invalid_rule_ignore(self):
-        with self.assertRaisesRegex(
-                config.YamlLintConfigError,
-                'invalid config: ignore should contain file patterns'):
-            config.YamlLintConfig('rules:\n'
-                                  '  colons:\n'
-                                  '    ignore: yes\n')
-
-    def test_invalid_locale(self):
-        with self.assertRaisesRegex(
-                config.YamlLintConfigError,
-                'invalid config: locale should be a string'):
-            config.YamlLintConfig('locale: yes\n')
-
-    def test_invalid_yaml_files(self):
-        with self.assertRaisesRegex(
-                config.YamlLintConfigError,
-                'invalid config: yaml-files should be a list of file '
-                'patterns'):
-            config.YamlLintConfig('yaml-files: yes\n')
-
 
 class ExtendedConfigTestCase(unittest.TestCase):
-    def test_extend_on_object(self):
+    def test_extend_add_rule(self):
         old = config.YamlLintConfig('rules:\n'
                                     '  colons:\n'
                                     '    max-spaces-before: 0\n'
@@ -242,152 +131,62 @@ 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(None)), 2)
+        self.assertEqual(len(new.enabled_rules()), 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):
-        with tempfile.NamedTemporaryFile('w') as f:
+        old = config.YamlLintConfig('rules:\n'
-            f.write('rules:\n'
                                     '  colons:\n'
                                     '    max-spaces-before: 0\n'
                                     '    max-spaces-after: 1\n'
                                     '  hyphens:\n'
                                     '    max-spaces-after: 2\n')
-            f.flush()
+        new = config.YamlLintConfig('rules:\n'
-            c = config.YamlLintConfig('extends: ' + f.name + '\n'
-                                      'rules:\n'
                                     '  colons: disable\n')
+        new.extend(old)
 
-        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
-        self.assertFalse(c.rules['colons'])
+        self.assertEqual(new.rules['colons'], False)
-        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
+        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
 
-        self.assertEqual(len(c.enabled_rules(None)), 1)
+        self.assertEqual(len(new.enabled_rules()), 1)
 
     def test_extend_edit_rule(self):
-        with tempfile.NamedTemporaryFile('w') as f:
+        old = config.YamlLintConfig('rules:\n'
-            f.write('rules:\n'
                                     '  colons:\n'
                                     '    max-spaces-before: 0\n'
                                     '    max-spaces-after: 1\n'
                                     '  hyphens:\n'
                                     '    max-spaces-after: 2\n')
-            f.flush()
+        new = config.YamlLintConfig('rules:\n'
-            c = config.YamlLintConfig('extends: ' + f.name + '\n'
-                                      'rules:\n'
                                     '  colons:\n'
                                     '    max-spaces-before: 3\n'
                                     '    max-spaces-after: 4\n')
+        new.extend(old)
 
-        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(c.rules['colons']['max-spaces-before'], 3)
+        self.assertEqual(new.rules['colons']['max-spaces-before'], 3)
-        self.assertEqual(c.rules['colons']['max-spaces-after'], 4)
+        self.assertEqual(new.rules['colons']['max-spaces-after'], 4)
-        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
+        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
 
-        self.assertEqual(len(c.enabled_rules(None)), 2)
+        self.assertEqual(len(new.enabled_rules()), 2)
 
     def test_extend_reenable_rule(self):
-        with tempfile.NamedTemporaryFile('w') as f:
+        old = config.YamlLintConfig('rules:\n'
-            f.write('rules:\n'
                                     '  colons:\n'
                                     '    max-spaces-before: 0\n'
                                     '    max-spaces-after: 1\n'
                                     '  hyphens: disable\n')
-            f.flush()
+        new = config.YamlLintConfig('rules:\n'
-            c = config.YamlLintConfig('extends: ' + f.name + '\n'
-                                      'rules:\n'
                                     '  hyphens:\n'
                                     '    max-spaces-after: 2\n')
+        new.extend(old)
 
-        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
+        self.assertEqual(new.rules['colons']['max-spaces-before'], 0)
-        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
+        self.assertEqual(new.rules['colons']['max-spaces-after'], 1)
-        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
+        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 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)
-
-    def test_extended_ignore_str(self):
-        with tempfile.NamedTemporaryFile('w') as f:
-            f.write('ignore: |\n'
-                    '  *.template.yaml\n')
-            f.flush()
-            c = config.YamlLintConfig('extends: ' + f.name + '\n')
-
-        self.assertEqual(c.ignore.match_file('test.template.yaml'), True)
-        self.assertEqual(c.ignore.match_file('test.yaml'), False)
-
-    def test_extended_ignore_list(self):
-        with tempfile.NamedTemporaryFile('w') as f:
-            f.write('ignore:\n'
-                    '  - "*.template.yaml"\n')
-            f.flush()
-            c = config.YamlLintConfig('extends: ' + f.name + '\n')
 
-        self.assertEqual(c.ignore.match_file('test.template.yaml'), True)
+        self.assertEqual(len(new.enabled_rules()), 2)
-        self.assertEqual(c.ignore.match_file('test.yaml'), False)
 
 
 class ExtendedLibraryConfigTestCase(unittest.TestCase):
@@ -419,9 +218,6 @@ 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')
@@ -435,329 +231,3 @@ 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 IgnoreConfigTestCase(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        super().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,
-        })
-
-        cls.backup_wd = os.getcwd()
-        os.chdir(cls.wd)
-
-    @classmethod
-    def tearDownClass(cls):
-        super().tearDownClass()
-
-        os.chdir(cls.backup_wd)
-
-        shutil.rmtree(cls.wd)
-
-    def test_mutually_exclusive_ignore_keys(self):
-        self.assertRaises(
-            YamlLintConfigError,
-            config.YamlLintConfig, 'extends: default\n'
-                                   'ignore-from-file: .gitignore\n'
-                                   'ignore: |\n'
-                                   '  *.dont-lint-me.yaml\n'
-                                   '  /bin/\n')
-
-    def test_ignore_from_file_not_exist(self):
-        self.assertRaises(
-            FileNotFoundError,
-            config.YamlLintConfig, 'extends: default\n'
-                                   'ignore-from-file: not_found_file\n')
-
-    def test_ignore_from_file_incorrect_type(self):
-        self.assertRaises(
-            YamlLintConfigError,
-            config.YamlLintConfig, 'extends: default\n'
-                                   'ignore-from-file: 0\n')
-        self.assertRaises(
-            YamlLintConfigError,
-            config.YamlLintConfig, 'extends: default\n'
-                                   'ignore-from-file: [0]\n')
-
-    def test_no_ignore(self):
-        sys.stdout = StringIO()
-        with self.assertRaises(SystemExit):
-            cli.run(('-f', 'parsable', '.'))
-
-        out = sys.stdout.getvalue()
-        out = '\n'.join(sorted(out.splitlines()))
-
-        keydup = '[error] duplication of key "key" in mapping (key-duplicates)'
-        trailing = '[error] trailing spaces (trailing-spaces)'
-        hyphen = '[error] too many spaces after hyphen (hyphens)'
-
-        self.assertEqual(out, '\n'.join((
-            './bin/file.lint-me-anyway.yaml:3:3: ' + keydup,
-            './bin/file.lint-me-anyway.yaml:4:17: ' + trailing,
-            './bin/file.lint-me-anyway.yaml:5:5: ' + hyphen,
-            './bin/file.yaml:3:3: ' + keydup,
-            './bin/file.yaml:4:17: ' + trailing,
-            './bin/file.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,
-            './file.dont-lint-me.yaml:3:3: ' + keydup,
-            './file.dont-lint-me.yaml:4:17: ' + trailing,
-            './file.dont-lint-me.yaml:5:5: ' + hyphen,
-            './ign-dup/file.yaml:3:3: ' + keydup,
-            './ign-dup/file.yaml:4:17: ' + trailing,
-            './ign-dup/file.yaml:5:5: ' + hyphen,
-            './ign-dup/sub/dir/file.yaml:3:3: ' + keydup,
-            './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:4:17: ' + trailing,
-            './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:4:17: ' + trailing,
-            './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:4:17: ' + trailing,
-            './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,
-        )))
-
-    def test_run_with_ignore_str(self):
-        with open(os.path.join(self.wd, '.yamllint'), 'w') as f:
-            f.write('extends: default\n'
-                    'ignore: |\n'
-                    '  *.dont-lint-me.yaml\n'
-                    '  /bin/\n'
-                    '  !/bin/*.lint-me-anyway.yaml\n'
-                    'rules:\n'
-                    '  key-duplicates:\n'
-                    '    ignore: |\n'
-                    '      /ign-dup\n'
-                    '  trailing-spaces:\n'
-                    '    ignore: |\n'
-                    '      ign-trail\n'
-                    '      !*.lint-me-anyway.yaml\n')
-
-        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,
-        )))
-
-    def test_run_with_ignore_list(self):
-        with open(os.path.join(self.wd, '.yamllint'), 'w') as f:
-            f.write('extends: default\n'
-                    'ignore:\n'
-                    '  - "*.dont-lint-me.yaml"\n'
-                    '  - "/bin/"\n'
-                    '  - "!/bin/*.lint-me-anyway.yaml"\n'
-                    'rules:\n'
-                    '  key-duplicates:\n'
-                    '    ignore:\n'
-                    '      - "/ign-dup"\n'
-                    '  trailing-spaces:\n'
-                    '    ignore:\n'
-                    '      - "ign-trail"\n'
-                    '      - "!*.lint-me-anyway.yaml"\n')
-
-        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,
-        )))
-
-    def test_run_with_ignore_from_file(self):
-        with open(os.path.join(self.wd, '.yamllint'), 'w') as f:
-            f.write('extends: default\n'
-                    'ignore-from-file: .gitignore\n')
-        with open(os.path.join(self.wd, '.gitignore'), 'w') as f:
-            f.write('*.dont-lint-me.yaml\n'
-                    '/bin/\n'
-                    '!/bin/*.lint-me-anyway.yaml\n')
-
-        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:3:3: ' + keydup,
-            './ign-dup/file.yaml:4:17: ' + trailing,
-            './ign-dup/file.yaml:5:5: ' + hyphen,
-            './ign-dup/sub/dir/file.yaml:3:3: ' + keydup,
-            './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:4:17: ' + trailing,
-            './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:4:17: ' + trailing,
-            './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:4:17: ' + trailing,
-            './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,
-        )))
-
-    def test_run_with_ignored_from_file(self):
-        with open(os.path.join(self.wd, '.yamllint'), 'w') as f:
-            f.write('ignore-from-file: [.gitignore, .yamlignore]\n'
-                    'extends: default\n')
-        with open(os.path.join(self.wd, '.gitignore'), 'w') as f:
-            f.write('*.dont-lint-me.yaml\n'
-                    '/bin/\n')
-        with open(os.path.join(self.wd, '.yamlignore'), 'w') as f:
-            f.write('!/bin/*.lint-me-anyway.yaml\n')
-
-        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:3:3: ' + keydup,
-            './ign-dup/file.yaml:4:17: ' + trailing,
-            './ign-dup/file.yaml:5:5: ' + hyphen,
-            './ign-dup/sub/dir/file.yaml:3:3: ' + keydup,
-            './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:4:17: ' + trailing,
-            './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:4:17: ' + trailing,
-            './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:4:17: ' + trailing,
-            './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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -14,6 +15,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import io
+
 import unittest
 
 from yamllint.config import YamlLintConfig
@@ -31,10 +33,10 @@ class LinterTestCase(unittest.TestCase):
         linter.run(b'test: document', self.fake_config())
 
     def test_run_on_unicode(self):
-        linter.run('test: document', self.fake_config())
+        linter.run(u'test: document', self.fake_config())
 
     def test_run_on_stream(self):
-        linter.run(io.StringIO('hello'), self.fake_config())
+        linter.run(io.StringIO(u'hello'), self.fake_config())
 
     def test_run_on_int(self):
         self.assertRaises(TypeError, linter.run, 42, self.fake_config())
@@ -42,25 +44,3 @@ class LinterTestCase(unittest.TestCase):
     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 = ('- hétérogénéité\n'
-             '# 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 = ('- お早う御座います。\n'
-             '# الأَبْجَدِيَّة العَرَبِيَّة\n')
-        linter.run(s, self.fake_config())
-        linter.run(s.encode('utf-8'), self.fake_config())
-
-    def test_linter_problem_repr_without_rule(self):
-        problem = linter.LintProblem(1, 2, 'problem')
-
-        self.assertEqual(str(problem), '1:2: problem')
-
-    def test_linter_problem_repr_with_rule(self):
-        problem = linter.LintProblem(1, 2, 'problem', 'rule-id')
-
-        self.assertEqual(str(problem), '1:2: problem (rule-id)')

tests/test_module.py

@@ -1,84 +0,0 @@
-# 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.assertRegex(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.assertRegex(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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -17,9 +18,8 @@ import unittest
 
 import yaml
 
-from yamllint.parser import (line_generator, token_or_comment_generator,
+from yamllint.parser import (line_generator, token_generator,
-                             token_or_comment_or_line_generator,
+                             token_or_line_generator, Line, Token)
-                             Line, Token, Comment)
 
 
 class ParserTestCase(unittest.TestCase):
@@ -61,84 +61,26 @@ class ParserTestCase(unittest.TestCase):
         self.assertEqual(e[2].line_no, 3)
         self.assertEqual(e[2].content, 'at the end')
 
-    def test_token_or_comment_generator(self):
+    def test_token_generator(self):
-        e = list(token_or_comment_generator(''))
+        e = list(token_generator(''))
         self.assertEqual(len(e), 2)
-        self.assertIsNone(e[0].prev)
+        self.assertEqual(e[0].prev, None)
         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.assertIsNone(e[1].next)
+        self.assertEqual(e[1].next, None)
 
-        e = list(token_or_comment_generator('---\n'
+        e = list(token_generator('---\n'
                                  'k: v\n'))
         self.assertEqual(len(e), 9)
         self.assertIsInstance(e[3].curr, yaml.KeyToken)
         self.assertIsInstance(e[5].curr, yaml.ValueToken)
 
-        e = list(token_or_comment_generator('# start comment\n'
+    def test_token_or_line_generator(self):
-                                            '- a\n'
+        e = list(token_or_line_generator('---\n'
-                                            '- key: val  # key=val\n'
+                                         'k: v\n'))
-                                            '# this is\n'
+        self.assertEqual(len(e), 12)
-                                            '# 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)
@@ -147,6 +89,5 @@ 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], Comment)
+        self.assertIsInstance(e[8], Line)
-        self.assertIsInstance(e[9], Line)
+        self.assertIsInstance(e[11], Line)
-        self.assertIsInstance(e[12], Line)

tests/test_spec_examples.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -13,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
@@ -46,14 +48,13 @@ 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'),
@@ -61,65 +62,63 @@ conf_overrides = {
                     'indentation: disable\n'),
     'example-2.12': ('empty-lines: {max-end: 1}\n'
                      'colons: {max-spaces-before: -1}\n'),
-    'example-2.16': 'empty-lines: {max-end: 1}\n',
+    'example-2.16': ('empty-lines: {max-end: 1}\n'),
-    'example-2.18': 'empty-lines: {max-end: 1}\n',
+    'example-2.18': ('empty-lines: {max-end: 1}\n'),
-    'example-2.19': 'empty-lines: {max-end: 1}\n',
+    'example-2.19': ('empty-lines: {max-end: 1}\n'),
-    'example-2.28': 'empty-lines: {max-end: 3}\n',
+    'example-2.28': ('empty-lines: {max-end: 3}\n'),
-    'example-5.3': ('indentation: {indent-sequences: false}\n'
+    'example-5.3': ('indentation: {indent-sequences: no}\n'
                     'colons: {max-spaces-before: 1}\n'),
-    'example-6.4': 'trailing-spaces: disable\n',
+    'example-6.4': ('trailing-spaces: disable\n'),
-    'example-6.5': 'trailing-spaces: disable\n',
+    'example-6.5': ('trailing-spaces: disable\n'),
-    'example-6.6': 'trailing-spaces: disable\n',
+    'example-6.6': ('trailing-spaces: disable\n'),
-    'example-6.7': 'trailing-spaces: disable\n',
+    'example-6.7': ('trailing-spaces: disable\n'),
-    'example-6.8': 'trailing-spaces: disable\n',
+    'example-6.8': ('trailing-spaces: disable\n'),
     'example-6.10': ('empty-lines: {max-end: 2}\n'
                      'trailing-spaces: disable\n'
                      'comments-indentation: disable\n'),
     'example-6.11': ('empty-lines: {max-end: 1}\n'
                      'comments-indentation: disable\n'),
-    'example-6.13': 'comments-indentation: disable\n',
+    'example-6.13': ('comments-indentation: disable\n'),
-    'example-6.14': 'comments-indentation: disable\n',
+    'example-6.14': ('comments-indentation: disable\n'),
-    'example-6.23': 'colons: {max-spaces-before: 1}\n',
+    'example-6.23': ('colons: {max-spaces-before: 1}\n'),
     'example-7.4': ('colons: {max-spaces-before: 1}\n'
                     'indentation: disable\n'),
-    'example-7.5': 'trailing-spaces: disable\n',
+    'example-7.5': ('trailing-spaces: disable\n'),
-    'example-7.6': 'trailing-spaces: disable\n',
+    'example-7.6': ('trailing-spaces: disable\n'),
-    'example-7.7': 'indentation: disable\n',
+    'example-7.7': ('indentation: disable\n'),
     'example-7.8': ('colons: {max-spaces-before: 1}\n'
                     'indentation: disable\n'),
-    'example-7.9': 'trailing-spaces: disable\n',
+    'example-7.9': ('trailing-spaces: disable\n'),
     'example-7.11': ('colons: {max-spaces-before: 1}\n'
                      'indentation: disable\n'),
     'example-7.13': ('brackets: {min-spaces-inside: 0, max-spaces-inside: 1}\n'
                      'commas: {max-spaces-before: 1, min-spaces-after: 0}\n'),
-    'example-7.14': 'indentation: disable\n',
+    'example-7.14': ('indentation: disable\n'),
     'example-7.15': ('braces: {min-spaces-inside: 0, max-spaces-inside: 1}\n'
                      'commas: {max-spaces-before: 1, min-spaces-after: 0}\n'
                      'colons: {max-spaces-before: 1}\n'),
-    'example-7.16': 'indentation: disable\n',
+    'example-7.16': ('indentation: disable\n'),
-    'example-7.17': 'indentation: disable\n',
+    'example-7.17': ('indentation: disable\n'),
-    'example-7.18': 'indentation: disable\n',
+    'example-7.18': ('indentation: disable\n'),
-    'example-7.19': 'indentation: disable\n',
+    'example-7.19': ('indentation: disable\n'),
     'example-7.20': ('colons: {max-spaces-before: 1}\n'
                      'indentation: disable\n'),
-    'example-8.1': 'empty-lines: {max-end: 1}\n',
+    'example-8.1': ('empty-lines: {max-end: 1}\n'),
-    'example-8.2': 'trailing-spaces: disable\n',
+    'example-8.2': ('trailing-spaces: disable\n'),
     'example-8.5': ('comments-indentation: disable\n'
                     'trailing-spaces: disable\n'),
-    'example-8.6': 'empty-lines: {max-end: 1}\n',
+    'example-8.6': ('empty-lines: {max-end: 1}\n'),
-    'example-8.7': 'empty-lines: {max-end: 1}\n',
+    'example-8.7': ('empty-lines: {max-end: 1}\n'),
-    'example-8.8': 'trailing-spaces: disable\n',
+    'example-8.8': ('trailing-spaces: disable\n'),
-    'example-8.9': 'empty-lines: {max-end: 1}\n',
+    'example-8.9': ('empty-lines: {max-end: 1}\n'),
-    'example-8.14': 'colons: {max-spaces-before: 1}\n',
+    'example-8.14': ('colons: {max-spaces-before: 1}\n'),
-    'example-8.16': 'indentation: {spaces: 1}\n',
+    'example-8.16': ('indentation: {spaces: 1}\n'),
-    'example-8.17': 'indentation: disable\n',
+    'example-8.17': ('indentation: disable\n'),
-    'example-8.20': ('indentation: {indent-sequences: false}\n'
+    'example-8.20': ('indentation: {indent-sequences: no}\n'
                      'colons: {max-spaces-before: 1}\n'),
-    'example-8.22': 'indentation: disable\n',
+    'example-8.22': ('indentation: disable\n'),
-    'example-10.1': 'colons: {max-spaces-before: 2}\n',
+    'example-10.1': ('colons: {max-spaces-before: 2}\n'),
-    'example-10.2': 'indentation: {indent-sequences: false}\n',
+    'example-10.2': ('indentation: {indent-sequences: no}\n'),
-    'example-10.8': 'truthy: disable\n',
-    'example-10.9': 'truthy: disable\n',
 }
 
 files = os.listdir(os.path.join(os.path.dirname(os.path.realpath(__file__)),
@@ -132,7 +131,6 @@ def _gen_test(buffer, conf):
         self.check(buffer, conf)
     return test
 
-
 # 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()).

tests/test_syntax_errors.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify

tests/test_yamllint_directives.py

@@ -1,432 +0,0 @@
-# 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_disable_directive_with_rules_and_dos_lines(self):
-        conf = self.conf + 'new-lines: {type: dos}\n'
-        self.check('---\r\n'
-                   '- [valid , YAML]\r\n'
-                   '# yamllint disable rule:trailing-spaces\r\n'
-                   '- trailing spaces    \r\n'
-                   '- bad   : colon\r\n'
-                   '- [valid , YAML]\r\n'
-                   '# yamllint enable rule:trailing-spaces\r\n'
-                   '- bad  : colon and spaces   \r\n'
-                   '- [valid , YAML]\r\n',
-                   conf,
-                   problem1=(5, 8, 'colons'),
-                   problem2=(8, 7, 'colons'),
-                   problem3=(8, 26, 'trailing-spaces'))
-        self.check('---\r\n'
-                   '- [valid , YAML]\r\n'
-                   '- trailing spaces    \r\n'
-                   '- bad   : colon\r\n'
-                   '- [valid , YAML]\r\n'
-                   '# yamllint disable-line rule:colons\r\n'
-                   '- bad  : colon and spaces   \r\n'
-                   '- [valid , YAML]\r\n',
-                   conf,
-                   problem1=(3, 18, 'trailing-spaces'),
-                   problem2=(4, 8, 'colons'),
-                   problem3=(7, 26, 'trailing-spaces'))
-
-    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)

yaml-fix-indentation

@@ -0,0 +1,50 @@
+#!/bin/bash
+
+set -euf
+
+DIR=$(dirname "$(readlink -f $0)")
+
+fix_one_problem_in_file() {
+  local filename=$1
+  local error
+  error=$(yamllint -f parsable "$filename" | grep 'wrong indentation: expected' \
+    | head -n 1)
+  if [ -z "$error" ]; then
+    return 1
+  fi
+  local line=$(echo $error | cut -d: -f2)
+  local expected=$(echo $error | cut -d: -f5 | sed 's/.* expected //;s/ but found.*//')
+  local found=$(echo $error | cut -d: -f5 | sed 's/.*but found //;s/(inde.*//')
+  "$DIR/yaml-remove-indentation" "$filename" $line $expected $found
+  return 0
+}
+
+reformat_yaml() {
+  local in=$1
+  local out=$2
+  python -c 'import sys, yaml; yaml.dump(yaml.load(sys.stdin), sys.stdout)' <"$in" >"$out"
+}
+
+fix_one_file() {
+  local filename=$1
+  local backup=$(mktemp originalXXXXX)
+  cp "$filename" "$backup"
+  echo "FIXING    $file"
+  while fix_one_problem_in_file "$filename"; do continue; done
+  echo "CHECKING  $file"
+  local tmp_old=$(mktemp oldXXXXX)
+  local tmp_new=$(mktemp newXXXXX)
+  reformat_yaml "$backup" "$tmp_old"
+  reformat_yaml "$filename" "$tmp_new"
+  if ! diff -q "$tmp_old" "$tmp_new" &>/dev/null; then
+    echo "error: after reformating, the file contents is detected different."
+    echo "diff $backup $filename"
+    echo "diff $tmp_old $tmp_new"
+    exit 1
+  fi
+  rm "$backup" "$tmp_old" "$tmp_new"
+}
+
+for file in "$@"; do
+  fix_one_file "$file"
+done

yaml-remove-indentation

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+
+import sys
+
+file = sys.argv[1]
+line = int(sys.argv[2]) - 1
+indent_expected = int(sys.argv[3])
+indent_found = int(sys.argv[4])
+
+with open(file) as f:
+    lines = f.readlines()
+
+    before = lines[:line]
+
+    is_a_list = lines[line].strip()[0] == '-'
+
+    i = line
+    while (i < len(lines) and
+           (lines[i].strip() == '' or
+            (not is_a_list and lines[i].startswith(indent_found * ' ')) or
+            (is_a_list and (lines[i].startswith(indent_found * ' ' + '-') or
+                            lines[i].startswith(indent_found * ' ' + ' '))))):
+        i += 1
+
+    contents = lines[line:i]
+    after = lines[i:]
+
+    new_contents = []
+    for line in contents:
+        if line.strip() != '':
+            line = (indent_expected * ' ') + line[indent_found:]
+        new_contents.append(line)
+
+with open(file, 'w') as f:
+    f.write(''.join(before))
+    f.write(''.join(new_contents))
+    f.write(''.join(after))

yamllint/__init__.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -21,10 +22,10 @@ indentation, etc."""
 
 
 APP_NAME = 'yamllint'
-APP_VERSION = '1.32.0'
+APP_VERSION = '1.2.1'
 APP_DESCRIPTION = __doc__
 
-__author__ = 'Adrien Vergé'
+__author__ = u'Adrien Vergé'
-__copyright__ = 'Copyright 2022, Adrien Vergé'
+__copyright__ = u'Copyright 2016, Adrien Vergé'
 __license__ = 'GPLv3'
 __version__ = APP_VERSION

yamllint/__main__.py

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

yamllint/cli.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -13,40 +14,29 @@
 # 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 argparse
+from __future__ import print_function
-import locale
+import os.path
-import os
-import platform
 import sys
 
+import argparse
+
 from yamllint import APP_DESCRIPTION, APP_NAME, APP_VERSION
-from yamllint import linter
 from yamllint.config import YamlLintConfig, YamlLintConfigError
-from yamllint.linter import PROBLEM_LEVELS
+from yamllint import linter
 
 
-def find_files_recursively(items, conf):
+def find_files_recursively(items):
     for item in items:
         if os.path.isdir(item):
             for root, dirnames, filenames in os.walk(item):
-                for f in filenames:
+                for filename in [f for f in filenames
-                    filepath = os.path.join(root, f)
+                                 if f.endswith(('.yml', '.yaml'))]:
-                    if conf.is_yaml_file(filepath):
+                    yield os.path.join(root, filename)
-                        yield filepath
         else:
             yield item
 
 
-def supports_color():
+class Format(object):
-    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:
     @staticmethod
     def parsable(problem, filename):
         return ('%(file)s:%(line)s:%(column)s: [%(level)s] %(message)s' %
@@ -58,17 +48,6 @@ class Format:
 
     @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':
@@ -81,124 +60,32 @@ class Format:
             line += '  \033[2m(%s)\033[0m' % problem.rule
         return line
 
-    @staticmethod
-    def github(problem, filename):
-        line = '::'
-        line += problem.level
-        line += ' file=' + filename + ','
-        line += 'line=' + format(problem.line) + ','
-        line += 'col=' + format(problem.column)
-        line += '::'
-        line += format(problem.line)
-        line += ':'
-        line += format(problem.column)
-        line += ' '
-        if problem.rule:
-            line += '[' + problem.rule + '] '
-        line += problem.desc
-        return line
-
-
-def show_problems(problems, file, args_format, no_warn):
-    max_level = 0
-    first = True
-
-    if args_format == 'auto':
-        if ('GITHUB_ACTIONS' in os.environ and
-                'GITHUB_WORKFLOW' in os.environ):
-            args_format = 'github'
-        elif supports_color():
-            args_format = 'colored'
-
-    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 == 'github':
-            if first:
-                print('::group::%s' % file)
-                first = False
-            print(Format.github(problem, file))
-        elif args_format == 'colored':
-            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 == 'github':
-        print('::endgroup::')
-
-    if not first and args_format != 'parsable':
-        print('')
-
-    return max_level
-
-
-def find_project_config_filepath(path='.'):
-    for filename in ('.yamllint', '.yamllint.yaml', '.yamllint.yml'):
-        filepath = os.path.join(path, filename)
-        if os.path.isfile(filepath):
-            return filepath
-
-    if os.path.abspath(path) == os.path.abspath(os.path.expanduser('~')):
-        return None
-    if os.path.abspath(path) == os.path.abspath(os.path.join(path, '..')):
-        return None
-    return find_project_config_filepath(path=os.path.join(path, '..'))
-
 
 def run(argv=None):
     parser = argparse.ArgumentParser(prog=APP_NAME,
                                      description=APP_DESCRIPTION)
-    files_group = parser.add_mutually_exclusive_group(required=True)
+    parser.add_argument('files', metavar='FILE_OR_DIR', nargs='+',
-    files_group.add_argument('files', metavar='FILE_OR_DIR', nargs='*',
-                             default=(),
                         help='files to check')
-    files_group.add_argument('-', action='store_true', dest='stdin',
+    parser.add_argument('-c', '--config-file', dest='config_file',
-                             help='read from standard input')
+                        action='store', help='path to a custom configuration')
-    config_group = parser.add_mutually_exclusive_group()
+    parser.add_argument('-d', '--config-data', dest='config_data',
-    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('--list-files', action='store_true', dest='list_files',
-                        help='list files to lint and exit')
     parser.add_argument('-f', '--format',
-                        choices=('parsable', 'standard', 'colored', 'github',
+                        choices=('parsable', 'standard'), default='standard',
-                                 '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='{} {}'.format(APP_NAME, APP_VERSION))
+                        version='%s %s' % (APP_NAME, APP_VERSION))
+
+    # TODO: read from stdin when no filename?
 
     args = parser.parse_args(argv)
 
-    if 'YAMLLINT_CONFIG_FILE' in os.environ:
+    if args.config_file is not None and args.config_data is not None:
-        user_global_config = os.path.expanduser(
+        print('Options --config-file and --config-data cannot be used '
-            os.environ['YAMLLINT_CONFIG_FILE'])
+              'simultaneously.', file=sys.stderr)
-    # User-global config is supposed to be in ~/.config/yamllint/config
+        sys.exit(-1)
-    elif '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')
 
-    project_config_filepath = find_project_config_filepath()
     try:
         if args.config_data is not None:
             if args.config_data != '' and ':' not in args.config_data:
@@ -206,55 +93,37 @@ def run(argv=None):
             conf = YamlLintConfig(content=args.config_data)
         elif args.config_file is not None:
             conf = YamlLintConfig(file=args.config_file)
-        elif project_config_filepath:
+        elif os.path.isfile('.yamllint'):
-            conf = YamlLintConfig(file=project_config_filepath)
+            conf = YamlLintConfig(file='.yamllint')
-        elif os.path.isfile(user_global_config):
-            conf = YamlLintConfig(file=user_global_config)
         else:
             conf = YamlLintConfig('extends: default')
     except YamlLintConfigError as e:
         print(e, file=sys.stderr)
         sys.exit(-1)
 
-    if conf.locale is not None:
+    return_code = 0
-        locale.setlocale(locale.LC_ALL, conf.locale)
-
-    if args.list_files:
-        for file in find_files_recursively(args.files, conf):
-            if not conf.is_file_ignored(file):
-                print(file)
-        sys.exit(0)
-
-    max_level = 0
 
-    for file in find_files_recursively(args.files, conf):
+    for file in find_files_recursively(args.files):
-        filepath = file[2:] if file.startswith('./') else file
         try:
-            with open(file, newline='') as f:
+            first = True
-                problems = linter.run(f, conf, filepath)
+            with open(file) as f:
-        except OSError as e:
+                for problem in linter.run(f, conf):
-            print(e, file=sys.stderr)
+                    if args.format == 'parsable':
-            sys.exit(-1)
+                        print(Format.parsable(problem, file))
-        prob_level = show_problems(problems, file, args_format=args.format,
+                    else:
-                                   no_warn=args.no_warnings)
+                        if first:
-        max_level = max(max_level, prob_level)
+                            print('\033[4m%s\033[0m' % file)
+                            first = False
 
-    # read yaml from stdin
+                        print(Format.standard(problem, file))
-    if args.stdin:
-        try:
-            problems = linter.run(sys.stdin, conf, '')
-        except OSError 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']:
+                    if return_code == 0 and problem.level == 'error':
                         return_code = 1
-    elif max_level == PROBLEM_LEVELS['warning']:
+
-        return_code = 2 if args.strict else 0
+            if not first and args.format != 'parsable':
-    else:
+                print('')
-        return_code = 0
+        except EnvironmentError as e:
+            print(e, file=sys.stderr)
+            return_code = -1
 
     sys.exit(return_code)

yamllint/conf/default.yaml

@@ -1,35 +1,44 @@
 ---
 
-yaml-files:
-  - '*.yaml'
-  - '*.yml'
-  - '.yamllint'
-
 rules:
-  anchors: enable
+  braces:
-  braces: enable
+    min-spaces-inside: 0
-  brackets: enable
+    max-spaces-inside: 0
-  colons: enable
+  brackets:
-  commas: enable
+    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
-  empty-lines: enable
+    present: yes
-  empty-values: disable
+  empty-lines:
-  float-values: disable
+    max: 2
-  hyphens: enable
+    max-start: 0
-  indentation: enable
+    max-end: 0
+  hyphens:
+    max-spaces-after: 1
+  indentation:
+    spaces: consistent
+    indent-sequences: yes
+    check-multi-line-strings: no
   key-duplicates: enable
-  key-ordering: disable
+  line-length:
-  line-length: enable
+    max: 80
+    allow-non-breakable-words: yes
   new-line-at-end-of-file: enable
-  new-lines: enable
+  new-lines:
-  octal-values: disable
+    type: unix
-  quoted-strings: disable
   trailing-spaces: enable
-  truthy:
-    level: warning

yamllint/conf/relaxed.yaml

@@ -25,5 +25,3 @@ rules:
     indent-sequences: consistent
   line-length:
     level: warning
-    allow-non-breakable-inline-mappings: true
-  truthy: disable

yamllint/config.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -13,10 +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 fileinput
 import os.path
 
-import pathspec
 import yaml
 
 import yamllint.rules
@@ -26,17 +25,10 @@ class YamlLintConfigError(Exception):
     pass
 
 
-class YamlLintConfig:
+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'])
-
-        self.locale = None
-
         if file is not None:
             with open(file) as f:
                 content = f.read()
@@ -44,23 +36,15 @@ class YamlLintConfig:
         self.parse(content)
         self.validate()
 
-    def is_file_ignored(self, filepath):
+    def enabled_rules(self):
-        return self.ignore and self.ignore.match_file(filepath)
-
-    def is_yaml_file(self, filepath):
-        return self.yaml_files.match_file(os.path.basename(filepath))
-
-    def enabled_rules(self, filepath):
         return [yamllint.rules.get(id) for id, val in self.rules.items()
-                if val is not False and (
+                if val is not False]
-                    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 (isinstance(self.rules[rule], dict) and
+            if (type(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])
@@ -69,24 +53,16 @@ class YamlLintConfig:
 
         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):
+        if type(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:
@@ -97,47 +73,6 @@ class YamlLintConfig:
             except Exception as e:
                 raise YamlLintConfigError('invalid config: %s' % e)
 
-        if 'ignore' in conf and 'ignore-from-file' in conf:
-            raise YamlLintConfigError(
-                'invalid config: ignore and ignore-from-file keys cannot be '
-                'used together')
-        elif 'ignore-from-file' in conf:
-            if isinstance(conf['ignore-from-file'], str):
-                conf['ignore-from-file'] = [conf['ignore-from-file']]
-            if not (isinstance(conf['ignore-from-file'], list) and all(
-                    isinstance(ln, str) for ln in conf['ignore-from-file'])):
-                raise YamlLintConfigError(
-                    'invalid config: ignore-from-file should contain '
-                    'filename(s), either as a list or string')
-            with fileinput.input(conf['ignore-from-file']) as f:
-                self.ignore = pathspec.PathSpec.from_lines('gitwildmatch', f)
-        elif 'ignore' in conf:
-            if isinstance(conf['ignore'], str):
-                self.ignore = pathspec.PathSpec.from_lines(
-                    'gitwildmatch', conf['ignore'].splitlines())
-            elif (isinstance(conf['ignore'], list) and
-                    all(isinstance(line, str) for line in conf['ignore'])):
-                self.ignore = pathspec.PathSpec.from_lines(
-                    'gitwildmatch', conf['ignore'])
-            else:
-                raise YamlLintConfigError(
-                    'invalid config: ignore should contain file patterns')
-
-        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'])
-
-        if 'locale' in conf:
-            if not isinstance(conf['locale'], str):
-                raise YamlLintConfigError(
-                    'invalid config: locale should be a string')
-            self.locale = conf['locale']
-
     def validate(self):
         for id in self.rules:
             try:
@@ -149,23 +84,12 @@ class YamlLintConfig:
 
 
 def validate_rule_conf(rule, conf):
-    if conf is False:  # disable
+    if conf is False or conf == 'disable':
         return False
+    elif conf == 'enable':
+        conf = {}
 
-    if isinstance(conf, dict):
+    if type(conf) == dict:
-        if ('ignore' in conf and
-                not isinstance(conf['ignore'], pathspec.pathspec.PathSpec)):
-            if isinstance(conf['ignore'], str):
-                conf['ignore'] = pathspec.PathSpec.from_lines(
-                    'gitwildmatch', conf['ignore'].splitlines())
-            elif (isinstance(conf['ignore'], list) and
-                    all(isinstance(line, str) for line in conf['ignore'])):
-                conf['ignore'] = pathspec.PathSpec.from_lines(
-                    'gitwildmatch', conf['ignore'])
-            else:
-                raise YamlLintConfigError(
-                    'invalid config: ignore should contain file patterns')
-
         if 'level' not in conf:
             conf['level'] = 'error'
         elif conf['level'] not in ('error', 'warning'):
@@ -173,49 +97,29 @@ def validate_rule_conf(rule, conf):
                 'invalid config: level should be "error" or "warning"')
 
         options = getattr(rule, 'CONF', {})
-        options_default = getattr(rule, 'DEFAULT', {})
         for optkey in conf:
-            if optkey in ('ignore', 'ignore-from-file', 'level'):
+            if optkey == 'level':
                 continue
             if optkey not in options:
                 raise YamlLintConfigError(
                     'invalid config: unknown option "%s" for rule "%s"' %
                     (optkey, rule.ID))
-            # Example: CONF = {option: (bool, 'mixed')}
+            if type(options[optkey]) == tuple:
-            #          → {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', int]}
-            #          → {option: [flag1]}      → {option: [42, flag1, flag2]}
-            elif isinstance(options[optkey], list):
-                if (type(conf[optkey]) is not list or
-                        any(flag not in options[optkey] and
-                            type(flag) not in options[optkey]
-                            for flag in conf[optkey])):
-                    raise YamlLintConfigError(
-                        ('invalid config: option "%s" of "%s" should only '
-                         'contain values in %s')
-                        % (optkey, rule.ID, str(options[optkey])))
-            # Example: CONF = {option: int}
-            #          → {option: 42}
             else:
-                if not isinstance(conf[optkey], options[optkey]):
+                if type(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:
-                conf[optkey] = options_default[optkey]
+                raise YamlLintConfigError(
-
+                    'invalid config: missing option "%s" for rule "%s"' %
-        if hasattr(rule, 'VALIDATE'):
+                    (optkey, rule.ID))
-            res = rule.VALIDATE(conf)
-            if res:
-                raise YamlLintConfigError('invalid config: %s: %s' %
-                                          (rule.ID, res))
     else:
         raise YamlLintConfigError(('invalid config: rule "%s": should be '
                                    'either "enable", "disable" or a dict')

yamllint/linter.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -13,28 +14,12 @@
 # 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 io
-
 import yaml
 
 from yamllint import parser
 
 
-PROBLEM_LEVELS = {
+class LintProblem(object):
-    0: None,
-    1: 'warning',
-    2: 'error',
-    None: 0,
-    'warning': 1,
-    'error': 2,
-}
-
-DISABLE_RULE_PATTERN = re.compile(r'^# yamllint disable( rule:\S+)*\s*$')
-ENABLE_RULE_PATTERN = re.compile(r'^# yamllint enable( rule:\S+)*\s*$')
-
-
-class LintProblem:
     """Represents a linting problem found by yamllint."""
     def __init__(self, line, column, desc='<no description>', rule=None):
         #: Line on which the problem was found (starting at 1)
@@ -50,7 +35,7 @@ class LintProblem:
     @property
     def message(self):
         if self.rule is not None:
-            return '{} ({})'.format(self.desc, self.rule)
+            return '%s (%s)' % (self.desc, self.rule)
         return self.desc
 
     def __eq__(self, other):
@@ -66,71 +51,18 @@ class LintProblem:
         return '%d:%d: %s' % (self.line, self.column, self.message)
 
 
-def get_cosmetic_problems(buffer, conf, filepath):
+def get_costemic_problems(buffer, conf):
-    rules = conf.enabled_rules(filepath)
+    rules = conf.enabled_rules()
 
     # 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] = {}
 
-    class DisableDirective:
+    for elem in parser.token_or_line_generator(buffer):
-        def __init__(self):
-            self.rules = set()
-            self.all_rules = {r.ID for r in rules}
-
-        def process_comment(self, comment):
-            comment = str(comment)
-
-            if DISABLE_RULE_PATTERN.match(comment):
-                items = comment[18:].rstrip().split(' ')
-                rules = [item[5:] for item in items][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 ENABLE_RULE_PATTERN.match(comment):
-                items = comment[17:].rstrip().split(' ')
-                rules = [item[5:] for item in items][1:]
-                if len(rules) == 0:
-                    self.rules.clear()
-                else:
-                    for id in rules:
-                        self.rules.discard(id)
-
-        def is_disabled_by_directive(self, problem):
-            return problem.rule in self.rules
-
-    class DisableLineDirective(DisableDirective):
-        def process_comment(self, comment):
-            comment = str(comment)
-
-            if re.match(r'^# yamllint disable-line( rule:\S+)*\s*$', comment):
-                items = comment[23:].rstrip().split(' ')
-                rules = [item[5:] for item in items][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 an 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]
@@ -140,39 +72,15 @@ def get_cosmetic_problems(buffer, conf, filepath):
                                           context[rule.ID]):
                     problem.rule = rule.ID
                     problem.level = rule_conf['level']
-                    cache.append(problem)
+                    yield 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:
@@ -180,42 +88,39 @@ 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)')
+                              'syntax error: ' + e.problem)
         problem.level = 'error'
         return problem
 
 
-def _run(buffer, conf, filepath):
+def _run(buffer, conf):
-    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_cosmetic_problems(buffer, conf, filepath):
+    for problem in get_costemic_problems(buffer, conf):
         # 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):
             yield syntax_error
 
-            # Discard the problem since it is at the same place as the syntax
+            # If there is already a yamllint error at the same place, discard
-            # error and is probably redundant (and maybe it's just a 'warning',
+            # it as it is probably redundant (and maybe it's just a 'warning',
             # in which case the script won't even exit with a failure status).
+            if (syntax_error.line == problem.line and
+                    syntax_error.column == problem.column):
                 syntax_error = None
                 continue
 
+            syntax_error = None
+
         yield problem
 
     if syntax_error:
         yield syntax_error
 
 
-def run(input, conf, filepath=None):
+def run(input, conf):
     """Lints a YAML source.
 
     Returns a generator of LintProblem objects.
@@ -223,14 +128,11 @@ def run(input, conf, filepath=None):
     :param input: buffer, string or stream to read from
     :param conf: yamllint configuration object
     """
-    if filepath is not None and conf.is_file_ignored(filepath):
+    if type(input) in (type(b''), type(u'')):  # compat with Python 2 & 3
-        return ()
+        return _run(input, conf)
-
+    elif hasattr(input, 'read'):  # Python 2's file or Python 3's io.IOBase
-    if isinstance(input, (bytes, str)):
-        return _run(input, conf, filepath)
-    elif isinstance(input, io.IOBase):
         # We need to have everything in memory to parse correctly
         content = input.read()
-        return _run(content, conf, filepath)
+        return _run(content, conf)
     else:
         raise TypeError('input should be a string or a stream')

yamllint/parser.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -16,7 +17,7 @@
 import yaml
 
 
-class Line:
+class Line(object):
     def __init__(self, line_no, buffer, start, end):
         self.line_no = line_no
         self.start = start
@@ -28,7 +29,7 @@ class Line:
         return self.buffer[self.start:self.end]
 
 
-class Token:
+class Token(object):
     def __init__(self, line_no, curr, prev, next, nextnext):
         self.line_no = line_no
         self.curr = curr
@@ -37,48 +38,11 @@ class Token:
         self.nextnext = nextnext
 
 
-class Comment:
-    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):
     line_no = 1
     cur = 0
     next = buffer.find('\n')
     while next != -1:
-        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)
@@ -87,39 +51,7 @@ def line_generator(buffer):
     yield Line(line_no, buffer, start=cur, end=len(buffer))
 
 
-def comments_between_tokens(token1, token2):
+def token_generator(buffer):
-    """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:
@@ -127,13 +59,10 @@ def token_or_comment_generator(buffer):
         curr = yaml_loader.get_token()
         while curr is not None:
             next = yaml_loader.get_token()
-            nextnext = (yaml_loader.peek_token()
+            nextnext = yaml_loader.peek_token()
-                        if yaml_loader.check_token() else None)
 
             yield Token(curr.start_mark.line + 1, curr, prev, next, nextnext)
 
-            yield from comments_between_tokens(curr, next)
-
             prev = curr
             curr = next
 
@@ -141,19 +70,19 @@ def token_or_comment_generator(buffer):
         pass
 
 
-def token_or_comment_or_line_generator(buffer):
+def token_or_line_generator(buffer):
     """Generator that mixes tokens and lines, ordering them by line number"""
-    tok_or_com_gen = token_or_comment_generator(buffer)
+    token_gen = token_generator(buffer)
     line_gen = line_generator(buffer)
 
-    tok_or_com = next(tok_or_com_gen, None)
+    token = next(token_gen, None)
     line = next(line_gen, None)
 
-    while tok_or_com is not None or line is not None:
+    while token is not None or line is not None:
-        if tok_or_com is None or (line is not None and
+        if token is None or (line is not None and
-                                  tok_or_com.line_no > line.line_no):
+                             token.line_no > line.line_no):
             yield line
             line = next(line_gen, None)
         else:
-            yield tok_or_com
+            yield token
-            tok_or_com = next(tok_or_com_gen, None)
+            token = next(token_gen, None)

yamllint/rules/__init__.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -14,7 +15,6 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from yamllint.rules import (
-    anchors,
     braces,
     brackets,
     colons,
@@ -24,23 +24,16 @@ from yamllint.rules import (
     document_end,
     document_start,
     empty_lines,
-    empty_values,
     hyphens,
     indentation,
     key_duplicates,
-    key_ordering,
     line_length,
     new_line_at_end_of_file,
     new_lines,
-    octal_values,
-    float_values,
-    quoted_strings,
     trailing_spaces,
-    truthy,
 )
 
 _RULES = {
-    anchors.ID: anchors,
     braces.ID: braces,
     brackets.ID: brackets,
     colons.ID: colons,
@@ -50,19 +43,13 @@ _RULES = {
     document_end.ID: document_end,
     document_start.ID: document_start,
     empty_lines.ID: empty_lines,
-    empty_values.ID: empty_values,
-    float_values.ID: float_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/anchors.py

@@ -1,174 +0,0 @@
-# Copyright (C) 2023 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/>.
-
-"""
-Use this rule to report duplicated anchors and aliases referencing undeclared
-anchors.
-
-.. rubric:: Options
-
-* Set ``forbid-undeclared-aliases`` to ``true`` to avoid aliases that reference
-  an anchor that hasn't been declared (either not declared at all, or declared
-  later in the document).
-* Set ``forbid-duplicated-anchors`` to ``true`` to avoid duplications of a same
-  anchor.
-* Set ``forbid-unused-anchors`` to ``true`` to avoid anchors being declared but
-  not used anywhere in the YAML document via alias.
-
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   anchors:
-     forbid-undeclared-aliases: true
-     forbid-duplicated-anchors: false
-     forbid-unused-anchors: false
-
-.. rubric:: Examples
-
-#. With ``anchors: {forbid-undeclared-aliases: true}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    ---
-    - &anchor
-      foo: bar
-    - *anchor
-
-   the following code snippet would **FAIL**:
-   ::
-
-    ---
-    - &anchor
-      foo: bar
-    - *unknown
-
-   the following code snippet would **FAIL**:
-   ::
-
-    ---
-    - &anchor
-      foo: bar
-    - <<: *unknown
-      extra: value
-
-#. With ``anchors: {forbid-duplicated-anchors: true}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    ---
-    - &anchor1 Foo Bar
-    - &anchor2 [item 1, item 2]
-
-   the following code snippet would **FAIL**:
-   ::
-
-    ---
-    - &anchor Foo Bar
-    - &anchor [item 1, item 2]
-
-#. With ``anchors: {forbid-unused-anchors: true}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    ---
-    - &anchor
-      foo: bar
-    - *anchor
-
-   the following code snippet would **FAIL**:
-   ::
-
-    ---
-    - &anchor
-      foo: bar
-    - items:
-      - item1
-      - item2
-"""
-
-
-import yaml
-
-from yamllint.linter import LintProblem
-
-
-ID = 'anchors'
-TYPE = 'token'
-CONF = {'forbid-undeclared-aliases': bool,
-        'forbid-duplicated-anchors': bool,
-        'forbid-unused-anchors': bool}
-DEFAULT = {'forbid-undeclared-aliases': True,
-           'forbid-duplicated-anchors': False,
-           'forbid-unused-anchors': False}
-
-
-def check(conf, token, prev, next, nextnext, context):
-    if (conf['forbid-undeclared-aliases'] or
-            conf['forbid-duplicated-anchors'] or
-            conf['forbid-unused-anchors']):
-        if isinstance(token, (
-                yaml.StreamStartToken,
-                yaml.DocumentStartToken,
-                yaml.DocumentEndToken)):
-            context['anchors'] = {}
-
-    if (conf['forbid-undeclared-aliases'] and
-            isinstance(token, yaml.AliasToken) and
-            token.value not in context['anchors']):
-        yield LintProblem(
-            token.start_mark.line + 1, token.start_mark.column + 1,
-            f'found undeclared alias "{token.value}"')
-
-    if (conf['forbid-duplicated-anchors'] and
-            isinstance(token, yaml.AnchorToken) and
-            token.value in context['anchors']):
-        yield LintProblem(
-            token.start_mark.line + 1, token.start_mark.column + 1,
-            f'found duplicated anchor "{token.value}"')
-
-    if conf['forbid-unused-anchors']:
-        # Unused anchors can only be detected at the end of Document.
-        # End of document can be either
-        #   - end of stream
-        #   - end of document sign '...'
-        #   - start of a new document sign '---'
-        # If next token indicates end of document,
-        # check if the anchors have been used or not.
-        # If they haven't been used, report problem on those anchors.
-        if isinstance(next, (yaml.StreamEndToken,
-                             yaml.DocumentStartToken,
-                             yaml.DocumentEndToken)):
-            for anchor, info in context['anchors'].items():
-                if not info['used']:
-                    yield LintProblem(info['line'] + 1,
-                                      info['column'] + 1,
-                                      f'found unused anchor "{anchor}"')
-        elif isinstance(token, yaml.AliasToken):
-            context['anchors'].get(token.value, {})['used'] = True
-
-    if (conf['forbid-undeclared-aliases'] or
-            conf['forbid-duplicated-anchors'] or
-            conf['forbid-unused-anchors']):
-        if isinstance(token, yaml.AnchorToken):
-            context['anchors'][token.value] = {
-                'line': token.start_mark.line,
-                'column': token.start_mark.column,
-                'used': False
-            }

yamllint/rules/braces.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -14,64 +15,17 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Use this rule to control the use of flow mappings or number of spaces inside
+Use this rule to control the number of spaces inside braces (``{`` and ``}``).
-braces (``{`` and ``}``).
 
 .. rubric:: Options
 
-* ``forbid`` is used to forbid the use of flow mappings which are denoted by
-  surrounding braces (``{`` and ``}``). Use ``true`` to forbid the use of flow
-  mappings completely. Use ``non-empty`` to forbid the use of all flow
-  mappings except for empty ones.
 * ``min-spaces-inside`` defines the minimal number of spaces required inside
   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:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   braces:
-     forbid: false
-     min-spaces-inside: 0
-     max-spaces-inside: 0
-     min-spaces-inside-empty: -1
-     max-spaces-inside-empty: -1
 
 .. rubric:: Examples
 
-#. With ``braces: {forbid: true}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    object:
-      key1: 4
-      key2: 8
-
-   the following code snippet would **FAIL**:
-   ::
-
-    object: { key1: 4, key2: 8 }
-
-#. With ``braces: {forbid: non-empty}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    object: {}
-
-   the following code snippet would **FAIL**:
-   ::
-
-    object: { key1: 4, key2: 8 }
-
 #. With ``braces: {min-spaces-inside: 0, max-spaces-inside: 0}``
 
    the following code snippet would **PASS**:
@@ -105,82 +59,22 @@ 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: {}
 """
 
 
 import yaml
 
-from yamllint.linter import LintProblem
 from yamllint.rules.common import spaces_after, spaces_before
 
 
 ID = 'braces'
 TYPE = 'token'
-CONF = {'forbid': (bool, 'non-empty'),
+CONF = {'min-spaces-inside': int,
-        'min-spaces-inside': int,
+        'max-spaces-inside': int}
-        'max-spaces-inside': int,
-        'min-spaces-inside-empty': int,
-        'max-spaces-inside-empty': int}
-DEFAULT = {'forbid': False,
-           'min-spaces-inside': 0,
-           'max-spaces-inside': 0,
-           'min-spaces-inside-empty': -1,
-           'max-spaces-inside-empty': -1}
 
 
 def check(conf, token, prev, next, nextnext, context):
-    if (conf['forbid'] is True and
+    if isinstance(token, yaml.FlowMappingStartToken):
-            isinstance(token, yaml.FlowMappingStartToken)):
-        yield LintProblem(token.start_mark.line + 1,
-                          token.end_mark.column + 1,
-                          'forbidden flow mapping')
-
-    elif (conf['forbid'] == 'non-empty' and
-            isinstance(token, yaml.FlowMappingStartToken) and
-            not isinstance(next, yaml.FlowMappingEndToken)):
-        yield LintProblem(token.start_mark.line + 1,
-                          token.end_mark.column + 1,
-                          'forbidden flow mapping')
-
-    elif (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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -14,65 +15,18 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Use this rule to control the use of flow sequences or the number of spaces
+Use this rule to control the number of spaces inside brackets (``[`` and
-inside brackets (``[`` and ``]``).
+``]``).
 
 .. rubric:: Options
 
-* ``forbid`` is used to forbid the use of flow sequences which are denoted by
-  surrounding brackets (``[`` and ``]``). Use ``true`` to forbid the use of
-  flow sequences completely. Use ``non-empty`` to forbid the use of all flow
-  sequences except for empty ones.
 * ``min-spaces-inside`` defines the minimal number of spaces required inside
   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:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   brackets:
-     forbid: false
-     min-spaces-inside: 0
-     max-spaces-inside: 0
-     min-spaces-inside-empty: -1
-     max-spaces-inside-empty: -1
 
 .. rubric:: Examples
 
-#. With ``brackets: {forbid: true}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    object:
-      - 1
-      - 2
-      - abc
-
-   the following code snippet would **FAIL**:
-   ::
-
-    object: [ 1, 2, abc ]
-
-#. With ``brackets: {forbid: non-empty}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    object: []
-
-   the following code snippet would **FAIL**:
-   ::
-
-    object: [ 1, 2, abc ]
-
 #. With ``brackets: {min-spaces-inside: 0, max-spaces-inside: 0}``
 
    the following code snippet would **PASS**:
@@ -106,83 +60,22 @@ 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: []
 """
 
 
 import yaml
 
-from yamllint.linter import LintProblem
 from yamllint.rules.common import spaces_after, spaces_before
 
 
 ID = 'brackets'
 TYPE = 'token'
-CONF = {'forbid': (bool, 'non-empty'),
+CONF = {'min-spaces-inside': int,
-        'min-spaces-inside': int,
+        'max-spaces-inside': int}
-        'max-spaces-inside': int,
-        'min-spaces-inside-empty': int,
-        'max-spaces-inside-empty': int}
-DEFAULT = {'forbid': False,
-           'min-spaces-inside': 0,
-           'max-spaces-inside': 0,
-           'min-spaces-inside-empty': -1,
-           'max-spaces-inside-empty': -1}
 
 
 def check(conf, token, prev, next, nextnext, context):
-    if (conf['forbid'] is True and
+    if isinstance(token, yaml.FlowSequenceStartToken):
-            isinstance(token, yaml.FlowSequenceStartToken)):
-        yield LintProblem(token.start_mark.line + 1,
-                          token.end_mark.column + 1,
-                          'forbidden flow sequence')
-
-    elif (conf['forbid'] == 'non-empty' and
-            isinstance(token, yaml.FlowSequenceStartToken) and
-            not isinstance(next, yaml.FlowSequenceEndToken)):
-        yield LintProblem(token.start_mark.line + 1,
-                          token.end_mark.column + 1,
-                          'forbidden flow sequence')
-
-    elif (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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -23,15 +24,6 @@ Use this rule to control the number of spaces before and after colons (``:``).
 * ``max-spaces-after`` defines the maximal number of spaces allowed after
   colons (use ``-1`` to disable).
 
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   colons:
-     max-spaces-before: 0
-     max-spaces-after: 1
-
 .. rubric:: Examples
 
 #. With ``colons: {max-spaces-before: 0, max-spaces-after: 1}``
@@ -80,21 +72,17 @@ Use this rule to control the number of spaces before and after colons (``:``).
 
 import yaml
 
-from yamllint.rules.common import is_explicit_key, spaces_after, spaces_before
+from yamllint.rules.common import spaces_after, spaces_before, is_explicit_key
 
 
 ID = 'colons'
 TYPE = 'token'
 CONF = {'max-spaces-before': int,
         'max-spaces-after': int}
-DEFAULT = {'max-spaces-before': 0,
-           'max-spaces-after': 1}
 
 
 def check(conf, token, prev, next, nextnext, context):
-    if isinstance(token, yaml.ValueToken) and not (
+    if isinstance(token, yaml.ValueToken):
-            isinstance(prev, yaml.AliasToken) and
-            token.start_mark.pointer - prev.end_mark.pointer == 1):
         problem = spaces_before(token, prev, next,
                                 max=conf['max-spaces-before'],
                                 max_desc='too many spaces before colon')

yamllint/rules/commas.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -25,16 +26,6 @@ Use this rule to control the number of spaces before and after commas (``,``).
 * ``max-spaces-after`` defines the maximal number of spaces allowed after
   commas (use ``-1`` to disable).
 
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   commas:
-     max-spaces-before: 0
-     min-spaces-after: 1
-     max-spaces-after: 1
-
 .. rubric:: Examples
 
 #. With ``commas: {max-spaces-before: 0}``
@@ -112,9 +103,6 @@ TYPE = 'token'
 CONF = {'max-spaces-before': int,
         'min-spaces-after': int,
         'max-spaces-after': int}
-DEFAULT = {'max-spaces-before': 0,
-           'min-spaces-after': 1,
-           'max-spaces-after': 1}
 
 
 def check(conf, token, prev, next, nextnext, context):

yamllint/rules/comments.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -19,27 +20,14 @@ 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 ``true`` to enable, ``false`` to disable.
+  ``#``. Set to ``yes`` to enable, ``no`` 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:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   comments:
-     require-starting-space: true
-     ignore-shebangs: true
-     min-spaces-from-content: 2
-
 .. rubric:: Examples
 
-#. With ``comments: {require-starting-space: true}``
+#. With ``comments: {require-starting-space: yes}``
 
    the following code snippet would **PASS**:
    ::
@@ -47,12 +35,6 @@ 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**:
    ::
 
@@ -73,41 +55,33 @@ Use this rule to control the position and formatting of comments.
 """
 
 
+import yaml
+
 from yamllint.linter import LintProblem
+from yamllint.rules.common import get_comments_between_tokens
 
 
 ID = 'comments'
-TYPE = 'comment'
+TYPE = 'token'
 CONF = {'require-starting-space': bool,
-        'ignore-shebangs': bool,
         'min-spaces-from-content': int}
-DEFAULT = {'require-starting-space': True,
-           'ignore-shebangs': True,
-           'min-spaces-from-content': 2}
 
 
-def check(conf, comment):
+def check(conf, token, prev, next, nextnext, context):
-    if (conf['min-spaces-from-content'] != -1 and comment.is_inline() and
+    for comment in get_comments_between_tokens(token, next):
-            comment.pointer - comment.token_before.end_mark.pointer <
+        if (conf['min-spaces-from-content'] != -1 and
+                not isinstance(token, yaml.StreamStartToken) and
+                comment.line == token.end_mark.line + 1):
+            # Sometimes token end marks are on the next line
+            if token.end_mark.buffer[token.end_mark.pointer - 1] != '\n':
+                if (comment.pointer - token.end_mark.pointer <
                         conf['min-spaces-from-content']):
-        yield LintProblem(comment.line_no, comment.column_no,
+                    yield LintProblem(comment.line, comment.column,
                                       'too few spaces before comment')
 
-    if conf['require-starting-space']:
+        if (conf['require-starting-space'] and
-        text_start = comment.pointer + 1
+                comment.pointer + 1 < len(comment.buffer) and
-        while (comment.buffer[text_start] == '#' and
+                comment.buffer[comment.pointer + 1] != ' ' and
-               text_start < len(comment.buffer)):
+                comment.buffer[comment.pointer + 1] != '\n'):
-            text_start += 1
+            yield LintProblem(comment.line, comment.column + 1,
-        if text_start < len(comment.buffer):
-            if (conf['ignore-shebangs'] and
-                    comment.line_no == 1 and
-                    comment.column_no == 1 and
-                    comment.buffer[text_start] == '!'):
-                return
-            # We can test for both \r and \r\n just by checking first char
-            # \r itself is a valid newline on some older OS.
-            elif comment.buffer[text_start] not in {' ', '\n', '\r', '\x00'}:
-                column = comment.column_no + text_start - comment.pointer
-                yield LintProblem(comment.line_no,
-                                  column,
                               'missing starting space in comment')

yamllint/rules/comments_indentation.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -77,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
+from yamllint.rules.common import get_line_indent, get_comments_between_tokens
 
 
 ID = 'comments-indentation'
-TYPE = 'comment'
+TYPE = 'token'
 
 
 # Case A:
@@ -97,41 +98,28 @@ TYPE = 'comment'
 #     # commented line 2
 #     current: line
 
-def check(conf, comment):
+def check(conf, token, prev, next, nextnext, context):
-    # Only check block comments
+    if prev is None:
-    if (not isinstance(comment.token_before, yaml.StreamStartToken) and
-            comment.token_before.end_mark.line + 1 == comment.line_no):
         return
 
-    next_line_indent = comment.token_after.start_mark.column
+    curr_line_indent = token.start_mark.column
-    if isinstance(comment.token_after, yaml.StreamEndToken):
+    if isinstance(token, yaml.StreamEndToken):
-        next_line_indent = 0
+        curr_line_indent = 0
 
-    if isinstance(comment.token_before, yaml.StreamStartToken):
+    skip_first_line = True
+    if isinstance(prev, yaml.StreamStartToken):
+        skip_first_line = False
         prev_line_indent = 0
     else:
-        prev_line_indent = get_line_indent(comment.token_before)
+        prev_line_indent = get_line_indent(prev)
-
+
-    # In the following case only the next line indent is valid:
+    if prev_line_indent <= curr_line_indent:
-    #     list:
+        prev_line_indent = -1  # disable it
-    #         # comment
+
-    #         - 1
+    for comment in get_comments_between_tokens(
-    #         - 2
+            prev, token, skip_first_line=skip_first_line):
-    prev_line_indent = max(prev_line_indent, next_line_indent)
+        if comment.column - 1 == curr_line_indent:
-
+            prev_line_indent = -1  # disable it
-    # If two indents are valid but a previous comment went back to normal
+        elif comment.column - 1 != prev_line_indent:
-    # indent, for the next ones to do the same. In other words, avoid this:
+            yield LintProblem(comment.line, comment.column,
-    #     list:
-    #         - 1
-    #     # comment on valid indent (0)
-    #         # comment on valid indent (4)
-    #     other-list:
-    #         - 2
-    if (comment.comment_before is not None and
-            not comment.comment_before.is_inline()):
-        prev_line_indent = comment.comment_before.column_no - 1
-
-    if (comment.column_no - 1 != prev_line_indent and
-            comment.column_no - 1 != next_line_indent):
-        yield LintProblem(comment.line_no, comment.column_no,
                               'comment not indented like content')

yamllint/rules/common.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -47,6 +48,27 @@ 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,
@@ -76,6 +98,35 @@ 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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -18,20 +19,12 @@ Use this rule to require or forbid the use of document end marker (``...``).
 
 .. rubric:: Options
 
-* Set ``present`` to ``true`` when the document end marker is required, or to
+* Set ``present`` to ``yes`` when the document end marker is required, or to
-  ``false`` when it is forbidden.
+  ``no`` when it is forbidden.
-
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   document-end:
-     present: true
 
 .. rubric:: Examples
 
-#. With ``document-end: {present: true}``
+#. With ``document-end: {present: yes}``
 
    the following code snippet would **PASS**:
    ::
@@ -56,7 +49,7 @@ Use this rule to require or forbid the use of document end marker (``...``).
     - is: another one
     ...
 
-#. With ``document-end: {present: false}``
+#. With ``document-end: {present: no}``
 
    the following code snippet would **PASS**:
    ::
@@ -89,23 +82,18 @@ from yamllint.linter import LintProblem
 ID = 'document-end'
 TYPE = 'token'
 CONF = {'present': bool}
-DEFAULT = {'present': True}
 
 
 def check(conf, token, prev, next, nextnext, context):
     if conf['present']:
-        is_stream_end = isinstance(token, yaml.StreamEndToken)
+        if (isinstance(token, yaml.StreamEndToken) and
-        is_start = isinstance(token, yaml.DocumentStartToken)
+                not (isinstance(prev, yaml.DocumentEndToken) or
-        prev_is_end_or_stream_start = isinstance(
+                     isinstance(prev, yaml.StreamStartToken))):
-            prev, (yaml.DocumentEndToken, yaml.StreamStartToken)
-        )
-        prev_is_directive = isinstance(prev, yaml.DirectiveToken)
-
-        if is_stream_end and not prev_is_end_or_stream_start:
             yield LintProblem(token.start_mark.line, 1,
                               'missing document end "..."')
-        elif is_start and not (prev_is_end_or_stream_start
+        elif (isinstance(token, yaml.DocumentStartToken) and
-                               or prev_is_directive):
+                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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -18,20 +19,12 @@ Use this rule to require or forbid the use of document start marker (``---``).
 
 .. rubric:: Options
 
-* Set ``present`` to ``true`` when the document start marker is required, or to
+* Set ``present`` to ``yes`` when the document start marker is required, or to
-  ``false`` when it is forbidden.
+  ``no`` when it is forbidden.
-
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   document-start:
-     present: true
 
 .. rubric:: Examples
 
-#. With ``document-start: {present: true}``
+#. With ``document-start: {present: yes}``
 
    the following code snippet would **PASS**:
    ::
@@ -52,7 +45,7 @@ Use this rule to require or forbid the use of document start marker (``---``).
     - this
     - is: another one
 
-#. With ``document-start: {present: false}``
+#. With ``document-start: {present: no}``
 
    the following code snippet would **PASS**:
    ::
@@ -79,7 +72,6 @@ from yamllint.linter import LintProblem
 ID = 'document-start'
 TYPE = 'token'
 CONF = {'present': bool}
-DEFAULT = {'present': True}
 
 
 def check(conf, token, prev, next, nextnext, context):

yamllint/rules/empty_lines.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -24,16 +25,6 @@ Use this rule to set a maximal number of allowed consecutive blank lines.
 * ``max-end`` defines the maximal number of empty lines allowed at the end of
   the file.  This option takes precedence over ``max``.
 
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   empty-lines:
-     max: 2
-     max-start: 0
-     max-end: 0
-
 .. rubric:: Examples
 
 #. With ``empty-lines: {max: 1}``
@@ -67,45 +58,32 @@ TYPE = 'line'
 CONF = {'max': int,
         'max-start': int,
         'max-end': int}
-DEFAULT = {'max': 2,
-           'max-start': 0,
-           'max-end': 0}
 
 
 def check(conf, line):
     if line.start == line.end and line.end < len(line.buffer):
-        # Only alert on the last blank line of a series
+        # Only alert on the last blank line of a serie
-        if (line.end + 2 <= len(line.buffer) and
+        if (line.end < len(line.buffer) - 1 and
-                line.buffer[line.end:line.end + 2] == '\n\n'):
+                line.buffer[line.end + 1] == '\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
 
-        start = line.start
+        while (line.start > blank_lines and
-        while start >= 2 and line.buffer[start - 2:start] == '\r\n':
+               line.buffer[line.start - blank_lines - 1] == '\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 start == 0:
+        if line.start - blank_lines == 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
+        if line.end == len(line.buffer) - 1 and line.buffer[line.end] == '\n':
-             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

@@ -1,104 +0,0 @@
-# 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:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   empty-values:
-     forbid-in-block-mappings: true
-     forbid-in-flow-mappings: true
-
-.. 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/float_values.py

@@ -1,158 +0,0 @@
-# Copyright (C) 2022 the yamllint contributors
-
-# 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 limit the permitted values for floating-point numbers.
-YAML permits three classes of float expressions: approximation to real numbers,
-positive and negative infinity and "not a number".
-
-.. rubric:: Options
-
-* Use ``require-numeral-before-decimal`` to require floats to start
-  with a numeral (ex ``0.0`` instead of ``.0``).
-* Use ``forbid-scientific-notation`` to forbid scientific notation.
-* Use ``forbid-nan`` to forbid NaN (not a number) values.
-* Use ``forbid-inf`` to forbid infinite values.
-
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
-    rules:
-      float-values:
-        forbid-inf: false
-        forbid-nan: false
-        forbid-scientific-notation: false
-        require-numeral-before-decimal: false
-
-.. rubric:: Examples
-
-#. With ``float-values: {require-numeral-before-decimal: true}``
-
-   the following code snippets would **PASS**:
-   ::
-
-    anemometer:
-      angle: 0.0
-
-   the following code snippets would **FAIL**:
-   ::
-
-    anemometer:
-      angle: .0
-
-#. With ``float-values: {forbid-scientific-notation: true}``
-
-   the following code snippets would **PASS**:
-   ::
-
-    anemometer:
-      angle: 0.00001
-
-   the following code snippets would **FAIL**:
-   ::
-
-    anemometer:
-      angle: 10e-6
-
-#. With ``float-values: {forbid-nan: true}``
-
-   the following code snippets would **FAIL**:
-   ::
-
-    anemometer:
-      angle: .NaN
-
- #. With ``float-values: {forbid-inf: true}``
-
-   the following code snippets would **FAIL**:
-   ::
-
-    anemometer:
-      angle: .inf
-"""
-
-import re
-
-import yaml
-
-from yamllint.linter import LintProblem
-
-
-ID = 'float-values'
-TYPE = 'token'
-CONF = {
-    'require-numeral-before-decimal': bool,
-    'forbid-scientific-notation': bool,
-    'forbid-nan': bool,
-    'forbid-inf': bool,
-}
-DEFAULT = {
-    'require-numeral-before-decimal': False,
-    'forbid-scientific-notation': False,
-    'forbid-nan': False,
-    'forbid-inf': False,
-}
-
-IS_NUMERAL_BEFORE_DECIMAL_PATTERN = (
-    re.compile('[-+]?(\\.[0-9]+)([eE][-+]?[0-9]+)?$')
-)
-IS_SCIENTIFIC_NOTATION_PATTERN = re.compile(
-    '[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)$'
-)
-IS_INF_PATTERN = re.compile('[-+]?(\\.inf|\\.Inf|\\.INF)$')
-IS_NAN_PATTERN = re.compile('(\\.nan|\\.NaN|\\.NAN)$')
-
-
-def check(conf, token, prev, next, nextnext, context):
-    if prev and isinstance(prev, yaml.tokens.TagToken):
-        return
-    if not isinstance(token, yaml.tokens.ScalarToken):
-        return
-    if token.style:
-        return
-    val = token.value
-
-    if conf['forbid-nan'] and IS_NAN_PATTERN.match(val):
-        yield LintProblem(
-            token.start_mark.line + 1,
-            token.start_mark.column + 1,
-            f'forbidden not a number value "{token.value}"',
-        )
-
-    if conf['forbid-inf'] and IS_INF_PATTERN.match(val):
-        yield LintProblem(
-            token.start_mark.line + 1,
-            token.start_mark.column + 1,
-            f'forbidden infinite value "{token.value}"',
-        )
-
-    if conf[
-        'forbid-scientific-notation'
-    ] and IS_SCIENTIFIC_NOTATION_PATTERN.match(val):
-        yield LintProblem(
-            token.start_mark.line + 1,
-            token.start_mark.column + 1,
-            f'forbidden scientific notation "{token.value}"',
-        )
-
-    if conf[
-        'require-numeral-before-decimal'
-    ] and IS_NUMERAL_BEFORE_DECIMAL_PATTERN.match(val):
-        yield LintProblem(
-            token.start_mark.line + 1,
-            token.start_mark.column + 1,
-            f'forbidden decimal missing 0 prefix "{token.value}"',
-        )

yamllint/rules/hyphens.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -21,14 +22,6 @@ Use this rule to control the number of spaces after hyphens (``-``).
 * ``max-spaces-after`` defines the maximal number of spaces allowed after
   hyphens.
 
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   hyphens:
-     max-spaces-after: 1
-
 .. rubric:: Examples
 
 #. With ``hyphens: {max-spaces-after: 1}``
@@ -83,7 +76,6 @@ from yamllint.rules.common import spaces_after
 ID = 'hyphens'
 TYPE = 'token'
 CONF = {'max-spaces-after': int}
-DEFAULT = {'max-spaces-after': 1}
 
 
 def check(conf, token, prev, next, nextnext, context):

yamllint/rules/indentation.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -24,22 +25,12 @@ Use this rule to control the indentation.
   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: ``true``,
+  perceive the ``-`` as part of the indentation). Possible values: ``yes``,
-  ``false``, ``whatever`` and ``consistent``. ``consistent`` requires either
+  ``no``, ``whatever`` and ``consistent``. ``consistent`` requires either all
-  all block sequences to be indented, or none to be. ``whatever`` means either
+  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 ``true`` to enable, ``false`` to disable.
+  multi-line strings. Set to ``yes`` to enable, ``no`` to disable.
-
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   indentation:
-     spaces: consistent
-     indent-sequences: true
-     check-multi-line-strings: false
 
 .. rubric:: Examples
 
@@ -108,7 +99,7 @@ Use this rule to control the indentation.
       Russian:
           dolls
 
-#. With ``indentation: {spaces: 2, indent-sequences: false}``
+#. With ``indentation: {spaces: 2, indent-sequences: no}``
 
    the following code snippet would **PASS**:
    ::
@@ -161,7 +152,7 @@ Use this rule to control the indentation.
       - spaghetti
       - sauce
 
-#. With ``indentation: {spaces: 4, check-multi-line-strings: true}``
+#. With ``indentation: {spaces: 4, check-multi-line-strings: yes}``
 
    the following code snippet would **PASS**:
    ::
@@ -202,7 +193,7 @@ Use this rule to control the indentation.
 import yaml
 
 from yamllint.linter import LintProblem
-from yamllint.rules.common import get_real_end_line, is_explicit_key
+from yamllint.rules.common import is_explicit_key, get_real_end_line
 
 
 ID = 'indentation'
@@ -210,15 +201,12 @@ TYPE = 'token'
 CONF = {'spaces': (int, 'consistent'),
         'indent-sequences': (bool, 'whatever', 'consistent'),
         'check-multi-line-strings': bool}
-DEFAULT = {'spaces': 'consistent',
-           'indent-sequences': True,
-           'check-multi-line-strings': False}
 
 ROOT, B_MAP, F_MAP, B_SEQ, F_SEQ, B_ENT, KEY, VAL = range(8)
 labels = ('ROOT', 'B_MAP', 'F_MAP', 'B_SEQ', 'F_SEQ', 'B_ENT', 'KEY', 'VAL')
 
 
-class Parent:
+class Parent(object):
     def __init__(self, type, indent, line_indent=None):
         self.type = type
         self.indent = indent
@@ -236,7 +224,7 @@ def check_scalar_indentation(conf, token, context):
 
     def compute_expected_indent(found_indent):
         def detect_indent(base_indent):
-            if not isinstance(context['spaces'], int):
+            if type(context['spaces']) is not int:
                 context['spaces'] = found_indent - base_indent
             return base_indent + context['spaces']
 
@@ -324,7 +312,7 @@ def _check(conf, token, prev, next, nextnext, context):
                      token.start_mark.line + 1 > context['cur_line'])
 
     def detect_indent(base_indent, next):
-        if not isinstance(context['spaces'], int):
+        if type(context['spaces']) is not int:
             context['spaces'] = next.start_mark.column - base_indent
         return base_indent + context['spaces']
 
@@ -341,18 +329,14 @@ def _check(conf, token, prev, next, nextnext, context):
             expected = detect_indent(expected, token)
 
         if found_indentation != expected:
-            if expected < 0:
+            yield LintProblem(token.start_mark.line + 1, found_indentation + 1,
-                message = 'wrong indentation: expected at least %d' % \
+                              'wrong indentation: expected %d but found %d' %
-                          (found_indentation + 1)
+                              (expected, found_indentation))
-            else:
-                message = 'wrong indentation: expected %d but found %d' % \
-                          (expected, found_indentation)
-            yield LintProblem(token.start_mark.line + 1,
-                              found_indentation + 1, message)
 
     if (isinstance(token, yaml.ScalarToken) and
             conf['check-multi-line-strings']):
-        yield from check_scalar_indentation(conf, token, context)
+        for problem in check_scalar_indentation(conf, token, context):
+            yield problem
 
     # Step 2.a:
 
@@ -415,10 +399,6 @@ def _check(conf, token, prev, next, nextnext, context):
             #   - item 1
             #   - item 2
             indent = next.start_mark.column
-        elif next.start_mark.column == token.start_mark.column:
-            #   -
-            #   key: value
-            indent = next.start_mark.column
         else:
             #   -
             #     item 1
@@ -489,19 +469,7 @@ def _check(conf, token, prev, next, nextnext, context):
                 if context['indent-sequences'] is False:
                     indent = context['stack'][-1].indent
                 elif context['indent-sequences'] is True:
-                    if (context['spaces'] == 'consistent' and
+                    indent = detect_indent(context['stack'][-1].indent, next)
-                            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 unknown value (-1).
-                        indent = -1
-                    else:
-                        indent = detect_indent(context['stack'][-1].indent,
-                                               next)
                 else:  # 'whatever' or 'consistent'
                     if next.start_mark.column == context['stack'][-1].indent:
                         #   key:
@@ -580,7 +548,8 @@ def _check(conf, token, prev, next, nextnext, context):
 
 def check(conf, token, prev, next, nextnext, context):
     try:
-        yield from _check(conf, token, prev, next, nextnext, context)
+        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,

yamllint/rules/key_duplicates.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -60,11 +61,12 @@ from yamllint.linter import LintProblem
 
 ID = 'key-duplicates'
 TYPE = 'token'
+CONF = {}
 
 MAP, SEQ = range(2)
 
 
-class Parent:
+class Parent(object):
     def __init__(self, type):
         self.type = type
         self.keys = []
@@ -83,16 +85,13 @@ def check(conf, token, prev, next, nextnext, context):
     elif isinstance(token, (yaml.BlockEndToken,
                             yaml.FlowMappingEndToken,
                             yaml.FlowSequenceEndToken)):
-        if len(context['stack']) > 0:
         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 (next.value in context['stack'][-1].keys and
+            if next.value in context['stack'][-1].keys:
-                    # `<<` 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

@@ -1,127 +0,0 @@
-# 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 default. As a result, the
-ordering is case-sensitive and not accent-friendly (see examples below).
-This can be changed by setting the global ``locale`` option.  This allows one
-to sort case and accents properly.
-
-.. 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
-
-#. With global option ``locale: "en_US.UTF-8"`` and rule ``key-ordering: {}``
-
-   as opposed to before, the following code snippet would now **PASS**:
-   ::
-
-    - t-shirt: 1
-      T-shirt: 2
-      t-shirts: 3
-      T-shirts: 4
-    - hair: true
-      haïr: true
-      hais: true
-      haïssable: true
-"""
-
-from locale import strcoll
-
-import yaml
-
-from yamllint.linter import LintProblem
-
-
-ID = 'key-ordering'
-TYPE = 'token'
-
-MAP, SEQ = range(2)
-
-
-class Parent:
-    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(strcoll(next.value, key) < 0
-                   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

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -21,19 +22,7 @@ Use this rule to set a limit to lines length.
 * ``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 ``true`` to allow, ``false`` to forbid.
+  instance. Use ``yes`` to allow, ``no`` 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:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   line-length:
-     max: 80
-     allow-non-breakable-words: true
-     allow-non-breakable-inline-mappings: false
 
 .. rubric:: Examples
 
@@ -53,7 +42,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: true}``
+#. With ``line-length: {max: 60, allow-non-breakable-words: yes}``
 
    the following code snippet would **PASS**:
    ::
@@ -70,22 +59,9 @@ 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 split...
+    - this line is waaaaaaaaaaaaaay too long but could be easily splitted...
-
-   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}``
+#. With ``line-length: {max: 60, allow-non-breakable-words: no}``
 
    the following code snippet would **FAIL**:
    ::
@@ -97,42 +73,17 @@ 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] == ' ':
@@ -140,19 +91,11 @@ def check(conf, line):
 
             if start != line.end:
                 if line.buffer[start] == '#':
-                    while line.buffer[start] == '#':
-                        start += 1
-                    start += 1
-                elif line.buffer[start] == '-':
                     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_line_at_end_of_file.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -17,7 +18,7 @@
 Use this rule to require a new line character (``\\n``) at the end of files.
 
 The POSIX standard `requires the last line to end with a new line character
-<https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_206>`_.
+<http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_206>`_.
 All UNIX tools expect a new line at the end of files. Most text editors use
 this convention too.
 """

yamllint/rules/new_lines.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify
@@ -18,42 +19,26 @@ Use this rule to force the type of new line characters.
 
 .. rubric:: Options
 
-* Set ``type`` to ``unix`` to enforce UNIX-typed new line characters (``\\n``),
+* Set ``type`` to ``unix`` to use UNIX-typed new line characters (``\\n``), or
-  set ``type`` to ``dos`` to enforce DOS-typed new line characters
+  ``dos`` to use DOS-typed new line characters (``\\r\\n``).
-  (``\\r\\n``), or set ``type`` to ``platform`` to infer the type from the
-  system running yamllint (``\\n`` on POSIX / UNIX / Linux / Mac OS systems or
-  ``\\r\\n`` on DOS / Windows systems).
-
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   new-lines:
-     type: unix
 """
 
-from os import linesep
 
 from yamllint.linter import LintProblem
 
 
 ID = 'new-lines'
 TYPE = 'line'
-CONF = {'type': ('unix', 'dos', 'platform')}
+CONF = {'type': ('unix', 'dos')}
-DEFAULT = {'type': 'unix'}
 
 
 def check(conf, line):
-    if conf['type'] == 'unix':
-        newline_char = '\n'
-    elif conf['type'] == 'platform':
-        newline_char = linesep
-    elif conf['type'] == 'dos':
-        newline_char = '\r\n'
-
     if line.start == 0 and len(line.buffer) > line.end:
-        if line.buffer[line.end:line.end + len(newline_char)] != newline_char:
+        if conf['type'] == 'dos':
+            if line.buffer[line.end - 1:line.end + 1] != '\r\n':
                 yield LintProblem(1, line.end - line.start + 1,
-                              'wrong new line character: expected {}'
+                                  'wrong new line character: expected \\r\\n')
-                              .format(repr(newline_char).strip('\'')))
+        else:
+            if line.end > 0 and line.buffer[line.end - 1] == '\r':
+                yield LintProblem(1, line.end - line.start,
+                                  'wrong new line character: expected \\n')

yamllint/rules/octal_values.py

@@ -1,114 +0,0 @@
-# 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:: Options
-
-* Use ``forbid-implicit-octal`` to prevent numbers starting with ``0``.
-* Use ``forbid-explicit-octal`` to prevent numbers starting with ``0o``.
-
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   octal-values:
-     forbid-implicit-octal: true
-     forbid-explicit-octal: true
-
-.. 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 re
-
-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}
-
-IS_OCTAL_NUMBER_PATTERN = re.compile(r'^[0-7]+$')
-
-
-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' and
-                        IS_OCTAL_NUMBER_PATTERN.match(val[1:])):
-                    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
-                        IS_OCTAL_NUMBER_PATTERN.match(val[2:])):
-                    yield LintProblem(
-                        token.start_mark.line + 1, token.end_mark.column + 1,
-                        'forbidden explicit octal value "%s"' %
-                        token.value)

yamllint/rules/quoted_strings.py

@@ -1,289 +0,0 @@
-# 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``).
-* ``extra-required`` is a list of PCRE regexes to force string values to be
-  quoted, if they match any regex. This option can only be used with
-  ``required: false`` and  ``required: only-when-needed``.
-* ``extra-allowed`` is a list of PCRE regexes to allow quoted string values,
-  even if ``required: only-when-needed`` is set.
-* ``allow-quoted-quotes`` allows (``true``) using disallowed quotes for strings
-  with allowed quotes inside. Default ``false``.
-
-**Note**: Multi-line strings (with ``|`` or ``>``) will not be checked.
-
-.. rubric:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   quoted-strings:
-     quote-type: any
-     required: true
-     extra-required: []
-     extra-allowed: []
-     allow-quoted-quotes: false
-
-.. 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'
-
-#. With ``quoted-strings: {required: false, extra-required: [^http://,
-   ^ftp://]}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    - localhost
-    - "localhost"
-    - "http://localhost"
-    - "ftp://localhost"
-
-   the following code snippet would **FAIL**:
-   ::
-
-    - http://localhost
-    - ftp://localhost
-
-#. With ``quoted-strings: {required: only-when-needed, extra-allowed:
-   [^http://, ^ftp://], extra-required: [QUOTED]}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    - localhost
-    - "http://localhost"
-    - "ftp://localhost"
-    - "this is a string that needs to be QUOTED"
-
-   the following code snippet would **FAIL**:
-   ::
-
-    - "localhost"
-    - this is a string that needs to be QUOTED
-
-#. With ``quoted-strings: {quote-type: double, allow-quoted-quotes: false}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    foo: "bar\\"baz"
-
-   the following code snippet would **FAIL**:
-   ::
-
-    foo: 'bar"baz'
-
-#. With ``quoted-strings: {quote-type: double, allow-quoted-quotes: true}``
-
-   the following code snippet would **PASS**:
-   ::
-
-    foo: 'bar"baz'
-
-"""
-
-import re
-
-import yaml
-
-from yamllint.linter import LintProblem
-
-ID = 'quoted-strings'
-TYPE = 'token'
-CONF = {'quote-type': ('any', 'single', 'double'),
-        'required': (True, False, 'only-when-needed'),
-        'extra-required': [str],
-        'extra-allowed': [str],
-        'allow-quoted-quotes': bool}
-DEFAULT = {'quote-type': 'any',
-           'required': True,
-           'extra-required': [],
-           'extra-allowed': [],
-           'allow-quoted-quotes': False}
-
-
-def VALIDATE(conf):
-    if conf['required'] is True and len(conf['extra-allowed']) > 0:
-        return 'cannot use both "required: true" and "extra-allowed"'
-    if conf['required'] is True and len(conf['extra-required']) > 0:
-        return 'cannot use both "required: true" and "extra-required"'
-    if conf['required'] is False and len(conf['extra-allowed']) > 0:
-        return 'cannot use both "required: false" and "extra-allowed"'
-
-
-DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'
-
-# https://stackoverflow.com/a/36514274
-yaml.resolver.Resolver.add_implicit_resolver(
-    'tag:yaml.org,2002:int',
-    re.compile(r'''^(?:[-+]?0b[0-1_]+
-               |[-+]?0o?[0-7_]+
-               |[-+]?0[0-7_]+
-               |[-+]?(?:0|[1-9][0-9_]*)
-               |[-+]?0x[0-9a-fA-F_]+
-               |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X),
-    list('-+0123456789'))
-
-
-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) and a.value == string):
-            return False
-        return True
-    except yaml.scanner.ScannerError:
-        return True
-
-
-def _has_quoted_quotes(token):
-    return ((not token.plain) and
-            ((token.style == "'" and '"' in token.value) or
-             (token.style == '"' and "'" in token.value)))
-
-
-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 in ("|", ">"):
-        return
-
-    quote_type = conf['quote-type']
-
-    msg = None
-    if conf['required'] is True:
-
-        # Quotes are mandatory and need to match config
-        if (token.style is None or
-            not (_quote_match(quote_type, token.style) or
-                 (conf['allow-quoted-quotes'] and _has_quoted_quotes(token)))):
-            msg = "string value is not quoted with %s quotes" % quote_type
-
-    elif conf['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) and
-                not (conf['allow-quoted-quotes'] and
-                     _has_quoted_quotes(token))):
-            msg = "string value is not quoted with %s quotes" % quote_type
-
-        elif not token.style:
-            is_extra_required = any(re.search(r, token.value)
-                                    for r in conf['extra-required'])
-            if is_extra_required:
-                msg = "string value is not quoted"
-
-    elif conf['required'] == 'only-when-needed':
-
-        # Quotes are not strictly needed here
-        if (token.style and tag == DEFAULT_SCALAR_TAG and token.value and
-                not _quotes_are_needed(token.value)):
-            is_extra_required = any(re.search(r, token.value)
-                                    for r in conf['extra-required'])
-            is_extra_allowed = any(re.search(r, token.value)
-                                   for r in conf['extra-allowed'])
-            if not (is_extra_required or is_extra_allowed):
-                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) and
-              not (conf['allow-quoted-quotes'] and _has_quoted_quotes(token))):
-            msg = "string value is not quoted with %s quotes" % quote_type
-
-        elif not token.style:
-            is_extra_required = len(conf['extra-required']) and any(
-                re.search(r, token.value) for r in conf['extra-required'])
-            if is_extra_required:
-                msg = "string value is not quoted"
-
-    if msg is not None:
-        yield LintProblem(
-            token.start_mark.line + 1,
-            token.start_mark.column + 1,
-            msg)

yamllint/rules/trailing_spaces.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # Copyright (C) 2016 Adrien Vergé
 #
 # This program is free software: you can redistribute it and/or modify

yamllint/rules/truthy.py

@@ -1,157 +0,0 @@
-# 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-explicitly 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:: Default values (when enabled)
-
-.. code-block:: yaml
-
- rules:
-   truthy:
-     allowed-values: ['true', 'false']
-     check-keys: true
-
-.. 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'])) + "]")