.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

@@ -1,7 +1,2 @@
 __pycache__
 *.py[cod]
-/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,18 @@
+---
+language: python
+python:
+  - 2.6
+  - 2.7
+  - 3.3
+  - 3.4
+  - 3.5
+  - nightly
+install:
+  - pip install pyyaml flake8 coveralls
+  - pip install .
+script:
+  - flake8 .
+  - yamllint $(git ls-files '*.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>.

README.md

@@ -0,0 +1,66 @@
+# yamllint
+
+A linter for YAML files.
+
+[![Build Status](https://travis-ci.org/adrienverge/yamllint.svg?branch=master)](https://travis-ci.org/adrienverge/yamllint)
+[![Coverage Status](https://coveralls.io/repos/adrienverge/yamllint/badge.svg?branch=master&service=github)](https://coveralls.io/github/adrienverge/yamllint?branch=master)
+
+Compatible with Python 2 & 3.
+
+## Usage
+
+```sh
+yamllint my_file.yml my_other_file.yaml ...
+```
+
+```sh
+yamllint -c ~/myconfig my_file.yml
+```
+
+```sh
+# To output a format parsable (by editors like Vim, emacs, etc.)
+yamllint -f parsable my_file.yml
+```
+
+## Installation
+
+```sh
+pip install yamllint
+```
+
+## Configuration
+
+There is no documentation yet, so here is what you need to know: you can
+override some rules, disable them or pass them in *warning* (instead of
+*error*). Have a look at the content of `yamllint/conf/default.yml` and create
+your own configuration file.
+
+It could look like this:
+
+```yaml
+# This is my first, very own configuration file for yamllint!
+# It extends the default conf by adjusting some options.
+
+extends: default
+
+rules:
+  # 80 should be enough, but don't fail if a line is longer
+  line-length:
+    max: 80
+    level: warning
+
+  # accept both
+  #    key:
+  #      - item
+  # and
+  #    key:
+  #    - item
+  indentation:
+    indent-sequences: whatever
+
+  # don't bother me with this rule
+  comments-indentation: disable
+```
+
+Tip: if you have a `.yamllint` file in your working directory, it will be
+automatically loaded as configuration by yamllint.

README.rst

@@ -1,140 +0,0 @@
-yamllint
-========
-
-A linter for YAML files.
-
-yamllint does not only check for syntax validity, but for weirdnesses like key
-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
-   :target: https://github.com/adrienverge/yamllint/actions/workflows/ci.yaml?query=branch%3Amaster
-   :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
-   :alt: Documentation status
-
-Written in Python (compatible with Python 3 only).
-
-Documentation
--------------
-
-https://yamllint.readthedocs.io/
-
-Overview
---------
-
-Screenshot
-^^^^^^^^^^
-
-.. image:: docs/screenshot.png
-   :alt: yamllint screenshot
-
-Installation
-^^^^^^^^^^^^
-
-Using pip, the Python package manager:
-
-.. code:: bash
-
- pip install --user yamllint
-
-yamllint is also packaged for all major operating systems, see installation
-examples (``dnf``, ``apt-get``...) `in the documentation
-<https://yamllint.readthedocs.io/en/stable/quickstart.html>`_.
-
-Usage
-^^^^^
-
-.. code:: bash
-
- # Lint one or more files
- yamllint my_file.yml my_other_file.yaml ...
-
-.. code:: bash
-
- # Lint all YAML files in a directory
- yamllint .
-
-.. code:: bash
-
- # Use a pre-defined lint configuration
- yamllint -d relaxed file.yaml
-
- # Use a custom lint configuration
- yamllint -c /path/to/myconfig file-to-lint.yaml
-
-.. code:: bash
-
- # Output a parsable format (for syntax checking in editors like Vim, emacs...)
- yamllint -f parsable file.yaml
-
-`Read more in the complete documentation! <https://yamllint.readthedocs.io/>`__
-
-Features
-^^^^^^^^
-
-Here is a yamllint configuration file example:
-
-.. code:: yaml
-
- extends: default
-
- rules:
-   # 80 chars should be enough, but don't fail if a line is longer
-   line-length:
-     max: 80
-     level: warning
-
-   # don't bother me with this rule
-   indentation: disable
-
-Within a YAML file, special comments can be used to disable checks for a single
-line:
-
-.. code:: yaml
-
- This line is waaaaaaaaaay too long  # yamllint disable-line
-
-or for a whole block:
-
-.. code:: yaml
-
- # yamllint disable rule:colons
- - Lorem       : ipsum
-   dolor       : sit amet,
-   consectetur : adipiscing elit
- # yamllint enable
-
-Specific files can be ignored (totally or for some rules only) using a
-``.gitignore``-style pattern:
-
-.. code:: yaml
-
- # For all rules
- ignore: |
-   *.dont-lint-me.yaml
-   /bin/
-   !/bin/*.lint-me-anyway.yaml
-
- rules:
-   key-duplicates:
-     ignore: |
-       generated
-       *.template.yaml
-   trailing-spaces:
-     ignore: |
-       *.ignore-trailing-spaces.yaml
-       /ascii-art/*
-
-`Read more in the complete documentation! <https://yamllint.readthedocs.io/>`__
-
-License
--------
-
-`GPL version 3 <LICENSE>`_

bin/yamllint

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (C) 2016 Adrien Vergé
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import print_function
+import os.path
+import sys
+
+import argparse
+
+from yamllint import APP_DESCRIPTION, APP_NAME, APP_VERSION
+from yamllint import config
+from yamllint.errors import YamlLintConfigError
+from yamllint import lint
+from yamllint import output
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(prog=APP_NAME,
+                                     description=APP_DESCRIPTION)
+    parser.add_argument('files', metavar='FILES', nargs='+',
+                        help='files to check')
+    parser.add_argument('-c', '--config', dest='config_file', action='store',
+                        help='path to a custom configuration')
+    parser.add_argument('-f', '--format',
+                        choices=('parsable', 'standard'), default='standard',
+                        help='format for parsing output')
+    parser.add_argument('-v', '--version', action='version',
+                        version='%s %s' % (APP_NAME, APP_VERSION))
+
+    # TODO: read from stdin when no filename?
+
+    args = parser.parse_args()
+
+    try:
+        if args.config_file is not None:
+            conf = config.parse_config_from_file(args.config_file)
+        elif os.path.isfile('.yamllint'):
+            conf = config.parse_config_from_file('.yamllint')
+        else:
+            conf = config.parse_config('extends: default')
+    except YamlLintConfigError as e:
+        print(e, file=sys.stderr)
+        sys.exit(-1)
+
+    return_code = 0
+
+    for file in args.files:
+        if args.format != 'parsable':
+            print('\033[4m%s\033[0m' % file)
+
+        try:
+            with open(file) as f:
+                for problem in lint(f, conf):
+                    if args.format == 'parsable':
+                        print(output.parsable_format(problem, file))
+                    else:
+                        print(output.standard_format(problem, file))
+
+                    if return_code == 0 and problem.level == 'error':
+                        return_code = 1
+        except EnvironmentError as e:
+            print(e)
+            return_code = -1
+
+        if args.format != 'parsable':
+            print('')
+
+    sys.exit(return_code)

docs/Makefile

@@ -1,177 +0,0 @@
-# Makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line.
-SPHINXOPTS    = -W
-SPHINXBUILD   = sphinx-build
-PAPER         =
-BUILDDIR      = _build
-
-# User-friendly check for sphinx-build
-ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
-$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
-endif
-
-# Internal variables.
-PAPEROPT_a4     = -D latex_paper_size=a4
-PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-# the i18n builder cannot share the environment and doctrees with the others
-I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-
-.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
-
-help:
-	@echo "Please use \`make <target>' where <target> is one of"
-	@echo "  html       to make standalone HTML files"
-	@echo "  dirhtml    to make HTML files named index.html in directories"
-	@echo "  singlehtml to make a single large HTML file"
-	@echo "  pickle     to make pickle files"
-	@echo "  json       to make JSON files"
-	@echo "  htmlhelp   to make HTML files and a HTML help project"
-	@echo "  qthelp     to make HTML files and a qthelp project"
-	@echo "  devhelp    to make HTML files and a Devhelp project"
-	@echo "  epub       to make an epub"
-	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
-	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
-	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
-	@echo "  text       to make text files"
-	@echo "  man        to make manual pages"
-	@echo "  texinfo    to make Texinfo files"
-	@echo "  info       to make Texinfo files and run them through makeinfo"
-	@echo "  gettext    to make PO message catalogs"
-	@echo "  changes    to make an overview of all changed/added/deprecated items"
-	@echo "  xml        to make Docutils-native XML files"
-	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
-	@echo "  linkcheck  to check all external links for integrity"
-	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
-
-clean:
-	rm -rf $(BUILDDIR)/*
-
-html:
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
-
-dirhtml:
-	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
-
-singlehtml:
-	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
-	@echo
-	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
-
-pickle:
-	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
-	@echo
-	@echo "Build finished; now you can process the pickle files."
-
-json:
-	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
-	@echo
-	@echo "Build finished; now you can process the JSON files."
-
-htmlhelp:
-	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
-	@echo
-	@echo "Build finished; now you can run HTML Help Workshop with the" \
-	      ".hhp project file in $(BUILDDIR)/htmlhelp."
-
-qthelp:
-	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
-	@echo
-	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
-	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
-	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/yamllint.qhcp"
-	@echo "To view the help file:"
-	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/yamllint.qhc"
-
-devhelp:
-	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
-	@echo
-	@echo "Build finished."
-	@echo "To view the help file:"
-	@echo "# mkdir -p $$HOME/.local/share/devhelp/yamllint"
-	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/yamllint"
-	@echo "# devhelp"
-
-epub:
-	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
-	@echo
-	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
-
-latex:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo
-	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
-	@echo "Run \`make' in that directory to run these through (pdf)latex" \
-	      "(use \`make latexpdf' here to do that automatically)."
-
-latexpdf:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through pdflatex..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-latexpdfja:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through platex and dvipdfmx..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-text:
-	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
-	@echo
-	@echo "Build finished. The text files are in $(BUILDDIR)/text."
-
-man:
-	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
-	@echo
-	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
-
-texinfo:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo
-	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
-	@echo "Run \`make' in that directory to run these through makeinfo" \
-	      "(use \`make info' here to do that automatically)."
-
-info:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo "Running Texinfo files through makeinfo..."
-	make -C $(BUILDDIR)/texinfo info
-	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
-
-gettext:
-	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
-	@echo
-	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
-
-changes:
-	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
-	@echo
-	@echo "The overview file is in $(BUILDDIR)/changes."
-
-linkcheck:
-	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
-	@echo
-	@echo "Link check complete; look for any errors in the above output " \
-	      "or in $(BUILDDIR)/linkcheck/output.txt."
-
-doctest:
-	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
-	@echo "Testing of doctests in the sources finished, look at the " \
-	      "results in $(BUILDDIR)/doctest/output.txt."
-
-xml:
-	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
-	@echo
-	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
-
-pseudoxml:
-	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
-	@echo
-	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."

docs/conf.py

@@ -1,54 +0,0 @@
-# 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('..'))
-
-from yamllint import __copyright__, APP_NAME, APP_VERSION  # noqa
-
-# -- General configuration ------------------------------------------------
-
-extensions = [
-    'sphinx.ext.autodoc',
-]
-
-source_suffix = '.rst'
-
-master_doc = 'index'
-
-project = APP_NAME
-copyright = __copyright__.lstrip('Copyright ')
-
-version = APP_VERSION
-release = APP_VERSION
-
-pygments_style = 'sphinx'
-
-# -- Options for HTML output ----------------------------------------------
-
-html_theme = 'default'
-
-htmlhelp_basename = 'yamllintdoc'
-
-# -- Options for manual page output ---------------------------------------
-
-# 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)
-]
-
-# -- 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,255 +0,0 @@
-Configuration
-=============
-
-yamllint uses a set of :doc:`rules <rules>` to check source files for problems.
-Each rule is independent from the others, and can be enabled, disabled or
-tweaked. All these settings can be gathered in a configuration file.
-
-To use a custom configuration file, use the ``-c`` option:
-
-.. code:: bash
-
- yamllint -c /path/to/myconfig file-to-lint.yaml
-
-If ``-c`` is not provided, yamllint will look for a configuration file in the
-following locations (by order of preference):
-
-- 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
----------------------
-
-Unless told otherwise, yamllint uses its ``default`` configuration:
-
-.. literalinclude:: ../yamllint/conf/default.yaml
-   :language: yaml
-
-Details on rules can be found on :doc:`the rules page <rules>`.
-
-There is another pre-defined configuration named ``relaxed``. As its name
-suggests, it is more tolerant:
-
-.. literalinclude:: ../yamllint/conf/relaxed.yaml
-   :language: yaml
-
-It can be chosen using:
-
-.. code:: bash
-
- yamllint -d relaxed file.yml
-
-Extending the default configuration
------------------------------------
-
-When writing a custom configuration file, you don't need to redefine every
-rule. Just extend the ``default`` configuration (or any already-existing
-configuration file).
-
-For instance, if you just want to disable the ``comments-indentation`` rule,
-your file could look like this:
-
-.. code-block:: yaml
-
- # This is my first, very own configuration file for yamllint!
- # It extends the default conf by adjusting some options.
-
- extends: default
-
- rules:
-   comments-indentation: disable  # don't bother me with this rule
-
-Similarly, if you want to set the ``line-length`` rule as a warning and be less
-strict on block sequences indentation:
-
-.. code-block:: yaml
-
- extends: default
-
- rules:
-   # 80 chars should be enough, but don't fail if a line is longer
-   line-length:
-     max: 80
-     level: warning
-
-   # accept both     key:
-   #                   - item
-   #
-   # and             key:
-   #                 - item
-   indentation:
-     indent-sequences: whatever
-
-Custom configuration without a config file
-------------------------------------------
-
-It is possible -- although not recommended -- to pass custom configuration
-options to yamllint with the ``-d`` (short for ``--config-data``) option.
-
-Its content can either be the name of a pre-defined conf (example: ``default``
-or ``relaxed``) or a serialized YAML object describing the configuration.
-
-For instance:
-
-.. code:: bash
-
- yamllint -d "{extends: relaxed, rules: {line-length: {max: 120}}}" file.yaml
-
-Errors and warnings
--------------------
-
-Problems detected by yamllint can be raised either as errors or as warnings.
-The CLI will output them (with different colors when using the ``colored``
-output format, or ``auto`` when run from a terminal).
-
-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

docs/development.rst

@@ -1,18 +0,0 @@
-Development
-===========
-
-yamllint provides both a script and a Python module. The latter can be used to
-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

@@ -1,29 +0,0 @@
-yamllint documentation
-======================
-
-.. automodule:: yamllint
-
-Screenshot
-----------
-
-.. image:: screenshot.png
-   :alt: yamllint screenshot
-
-.. note::
-
-   The default output format is inspired by `eslint <https://eslint.org/>`_, a
-   great linting tool for Javascript.
-
-Table of contents
------------------
-
-.. toctree::
-   :maxdepth: 2
-
-   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

@@ -1,115 +0,0 @@
-Quickstart
-==========
-
-Installing yamllint
--------------------
-
-On Fedora / CentOS (note: `EPEL <https://docs.fedoraproject.org/en-US/epel/>`_ is
-required on CentOS):
-
-.. code:: bash
-
- sudo dnf install yamllint
-
-On Debian 8+ / Ubuntu 16.04+:
-
-.. code:: bash
-
- sudo apt-get install yamllint
-
-On Mac OS 10.11+:
-
-.. code:: bash
-
- brew install yamllint
-
-On FreeBSD:
-
-.. code:: sh
-
-  pkg install py36-yamllint
-
-On OpenBSD:
-
-.. code:: sh
-
-  doas pkg_add py3-yamllint
-
-Alternatively using pip, the Python package manager:
-
-.. code:: bash
-
- pip install --user yamllint
-
-If you prefer installing from source, you can run, from the source directory:
-
-.. code:: bash
-
- python -m build
- pip install --user dist/yamllint-*.tar.gz
-
-Running yamllint
-----------------
-
-Basic usage:
-
-.. code:: bash
-
- yamllint file.yml other-file.yaml
-
-You can also lint all YAML files in a whole directory:
-
-.. code:: bash
-
- yamllint .
-
-Or lint a YAML stream from standard input:
-
-.. code:: bash
-
- echo -e 'this: is\nvalid: YAML' | yamllint -
-
-The output will look like (colors are not displayed here):
-
-::
-
- file.yml
-   1:4       error    trailing spaces  (trailing-spaces)
-   4:4       error    wrong indentation: expected 4 but found 3  (indentation)
-   5:4       error    duplication of key "id-00042" in mapping  (key-duplicates)
-   6:6       warning  comment not indented like content  (comments-indentation)
-   12:6      error    too many spaces after hyphen  (hyphens)
-   15:12     error    too many spaces before comma  (commas)
-
- other-file.yaml
-   1:1       warning  missing document start "---"  (document-start)
-   6:81      error    line too long (87 > 80 characters)  (line-length)
-   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:
-
-::
-
- file.yml:6:2: [warning] missing starting space in comment (comments)
- file.yml:57:1: [error] trailing spaces (trailing-spaces)
- file.yml:60:3: [error] wrong indentation: expected 4 but found 2 (indentation)
-
-If you have a custom linting configuration file (see :doc:`how to configure
-yamllint <configuration>`), it can be passed to yamllint using the ``-c``
-option:
-
-.. code:: bash
-
- yamllint -c ~/myconfig file.yaml
-
-.. note::
-
-   If you have a ``.yamllint`` file in your working directory, it will be
-   automatically loaded as configuration by yamllint.

docs/rules.rst

@@ -1,131 +0,0 @@
-Rules
-=====
-
-When linting a document with yamllint, a series of rules (such as
-``line-length``, ``trailing-spaces``, etc.) are checked against.
-
-A :doc:`configuration file <configuration>` can be used to enable or disable
-these rules, to set their level (*error* or *warning*), but also to tweak their
-options.
-
-This page describes the rules and their options.
-
-.. contents:: List of rules
-   :local:
-   :depth: 1
-
-anchors
--------
-
-.. automodule:: yamllint.rules.anchors
-
-braces
-------
-
-.. automodule:: yamllint.rules.braces
-
-brackets
---------
-
-.. automodule:: yamllint.rules.brackets
-
-colons
-------
-
-.. automodule:: yamllint.rules.colons
-
-commas
-------
-
-.. automodule:: yamllint.rules.commas
-
-comments
---------
-
-.. automodule:: yamllint.rules.comments
-
-comments-indentation
---------------------
-
-.. automodule:: yamllint.rules.comments_indentation
-
-document-end
-------------
-
-.. automodule:: yamllint.rules.document_end
-
-document-start
---------------
-
-.. automodule:: yamllint.rules.document_start
-
-empty-lines
------------
-
-.. automodule:: yamllint.rules.empty_lines
-
-empty-values
-------------
-
-.. automodule:: yamllint.rules.empty_values
-
-float-values
-------------
-
-.. automodule:: yamllint.rules.float_values
-
-
-hyphens
--------
-
-.. automodule:: yamllint.rules.hyphens
-
-indentation
------------
-
-.. automodule:: yamllint.rules.indentation
-
-key-duplicates
---------------
-
-.. automodule:: yamllint.rules.key_duplicates
-
-key-ordering
---------------
-
-.. automodule:: yamllint.rules.key_ordering
-
-line-length
------------
-
-.. automodule:: yamllint.rules.line_length
-
-new-line-at-end-of-file
------------------------
-
-.. automodule:: yamllint.rules.new_line_at_end_of_file
-
-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

@@ -1,52 +0,0 @@
-Integration with text editors
-=============================
-
-Most text editors support syntax checking and highlighting, to visually report
-syntax errors and warnings to the user. yamllint can be used to syntax-check
-YAML source, but a bit of configuration is required depending on your favorite
-text editor.
-
-Vim
----
-
-Assuming that the `ALE <https://github.com/dense-analysis/ale>`_ plugin is
-installed, yamllint is supported by default. It is automatically enabled when
-editing YAML files.
-
-If you instead use the `syntastic <https://github.com/vim-syntastic/syntastic>`_
-plugin, add this to your ``.vimrc``:
-
-::
-
- let g:syntastic_yaml_checkers = ['yamllint']
-
-Neovim
-------
-
-Assuming that the `neomake <https://github.com/neomake/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
-------------------
-
-.. rubric:: Help wanted!
-
-Your favorite text editor is not listed here? Help us improve by adding a
-section (by opening a pull-request or issue on GitHub).

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,37 @@
 # 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,
+    license=__license__,
+    keywords=['yaml', 'lint', 'linter'],
+    url='https://github.com/adrienverge/yamllint',
+    classifiers=[
+        'Development Status :: 4 - Beta',
+        '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(),
+    scripts=['bin/yamllint'],
+    package_data={'yamllint': ['conf/*.yml']},
+    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/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
@@ -13,16 +14,13 @@
 # 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
 
-from yamllint.config import YamlLintConfig
+from yamllint.config import parse_config
-from yamllint import linter
+from yamllint.errors import LintProblem
+from yamllint import lint
 
 
 class RuleTestCase(unittest.TestCase):
@@ -33,7 +31,7 @@ class RuleTestCase(unittest.TestCase):
             conf = yaml.safe_load(conf)
         conf = {'extends': 'default',
                 'rules': conf}
-        return YamlLintConfig(yaml.safe_dump(conf))
+        return parse_config(yaml.safe_dump(conf))
 
     def check(self, source, conf, **kwargs):
         expected_problems = []
@@ -46,41 +44,9 @@ class RuleTestCase(unittest.TestCase):
                     rule_id = kwargs[key][2]
             else:
                 rule_id = self.rule_id
-            expected_problems.append(linter.LintProblem(
+            expected_problems.append(
-                kwargs[key][0], kwargs[key][1], rule=rule_id))
+                LintProblem(kwargs[key][0], kwargs[key][1], rule=rule_id))
         expected_problems.sort()
 
-        real_problems = list(linter.run(source, self.build_fake_config(conf)))
+        real_problems = list(lint(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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class ColonTestCase(RuleTestCase):
@@ -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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class ColonTestCase(RuleTestCase):
@@ -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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class ColonTestCase(RuleTestCase):
@@ -117,7 +118,7 @@ class ColonTestCase(RuleTestCase):
                    '...\n', conf, problem=(3, 8))
 
     def test_before_with_explicit_block_mappings(self):
-        conf = 'colons: {max-spaces-before: 0, max-spaces-after: 1}'
+        conf = 'colons: {max-spaces-before: 0, max-spaces-after: -1}'
         self.check('---\n'
                    'object:\n'
                    '  ? key\n'
@@ -128,30 +129,6 @@ class ColonTestCase(RuleTestCase):
                    '  ? key\n'
                    '  : value\n'
                    '...\n', conf, problem=(2, 7))
-        self.check('---\n'
-                   '? >\n'
-                   '    multi-line\n'
-                   '    key\n'
-                   ': >\n'
-                   '    multi-line\n'
-                   '    value\n'
-                   '...\n', conf)
-        self.check('---\n'
-                   '- ? >\n'
-                   '      multi-line\n'
-                   '      key\n'
-                   '  : >\n'
-                   '      multi-line\n'
-                   '      value\n'
-                   '...\n', conf)
-        self.check('---\n'
-                   '- ? >\n'
-                   '      multi-line\n'
-                   '      key\n'
-                   '  :  >\n'
-                   '       multi-line\n'
-                   '       value\n'
-                   '...\n', conf, problem=(5, 5))
 
     def test_after_enabled(self):
         conf = 'colons: {max-spaces-before: -1, max-spaces-after: 1}'
@@ -256,19 +233,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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class CommaTestCase(RuleTestCase):
@@ -32,25 +33,9 @@ class CommaTestCase(RuleTestCase):
                    '  key2: val2,\n'
                    '}\n'
                    '...\n', conf)
-        self.check('---\n'
-                   '- [one, two , three,four]\n'
-                   '- {five,six , seven, eight}\n'
-                   '- [\n'
-                   '  nine,  ten\n'
-                   '  , eleven\n'
-                   '  ,twelve\n'
-                   ']\n'
-                   '- {\n'
-                   '  thirteen: 13,  fourteen\n'
-                   '  , fifteen: 15\n'
-                   '  ,sixteen: 16\n'
-                   '}\n', conf)
 
-    def test_before_max(self):
+    def test_before_enabled(self):
-        conf = ('commas:\n'
+        conf = 'commas: {max-spaces-before: 0, max-spaces-after: -1}'
-                '  max-spaces-before: 0\n'
-                '  min-spaces-after: 0\n'
-                '  max-spaces-after: -1\n')
         self.check('---\n'
                    'array: [1, 2,  3, 4]\n'
                    '...\n', conf)
@@ -90,51 +75,8 @@ class CommaTestCase(RuleTestCase):
                    '  key2: val2 ,\n'
                    '}\n', conf, problem=(4, 13))
 
-    def test_before_max_with_comma_on_new_line(self):
+    def test_before_max(self):
-        conf = ('commas:\n'
+        conf = 'commas: {max-spaces-before: 3, max-spaces-after: -1}'
-                '  max-spaces-before: 0\n'
-                '  min-spaces-after: 0\n'
-                '  max-spaces-after: -1\n')
-        self.check('---\n'
-                   'flow-seq: [1, 2, 3\n'
-                   '           , 4, 5, 6]\n'
-                   '...\n', conf, problem=(3, 11))
-        self.check('---\n'
-                   'flow-map: {a: 1, b: 2\n'
-                   '           , c: 3}\n'
-                   '...\n', conf, problem=(3, 11))
-
-        conf = ('commas:\n'
-                '  max-spaces-before: 0\n'
-                '  min-spaces-after: 0\n'
-                '  max-spaces-after: -1\n'
-                'indentation: disable\n')
-        self.check('---\n'
-                   'flow-seq: [1, 2, 3\n'
-                   '         , 4, 5, 6]\n'
-                   '...\n', conf, problem=(3, 9))
-        self.check('---\n'
-                   'flow-map: {a: 1, b: 2\n'
-                   '         , c: 3}\n'
-                   '...\n', conf, problem=(3, 9))
-        self.check('---\n'
-                   '[\n'
-                   '1,\n'
-                   '2\n'
-                   ', 3\n'
-                   ']\n', conf, problem=(5, 1))
-        self.check('---\n'
-                   '{\n'
-                   'a: 1,\n'
-                   'b: 2\n'
-                   ', c: 3\n'
-                   '}\n', conf, problem=(5, 1))
-
-    def test_before_max_3(self):
-        conf = ('commas:\n'
-                '  max-spaces-before: 3\n'
-                '  min-spaces-after: 0\n'
-                '  max-spaces-after: -1\n')
         self.check('---\n'
                    'array: [1 , 2, 3   , 4]\n'
                    '...\n', conf)
@@ -148,32 +90,8 @@ class CommaTestCase(RuleTestCase):
                    '  key: val,\n'
                    ']\n', conf, problem=(4, 11))
 
-    def test_after_min(self):
+    def test_after_enabled(self):
-        conf = ('commas:\n'
+        conf = 'commas: {max-spaces-before: -1, max-spaces-after: 1}'
-                '  max-spaces-before: -1\n'
-                '  min-spaces-after: 1\n'
-                '  max-spaces-after: -1\n')
-        self.check('---\n'
-                   '- [one, two , three,four]\n'
-                   '- {five,six , seven, eight}\n'
-                   '- [\n'
-                   '  nine,  ten\n'
-                   '  , eleven\n'
-                   '  ,twelve\n'
-                   ']\n'
-                   '- {\n'
-                   '  thirteen: 13,  fourteen\n'
-                   '  , fifteen: 15\n'
-                   '  ,sixteen: 16\n'
-                   '}\n', conf,
-                   problem1=(2, 21), problem2=(3, 9),
-                   problem3=(7, 4), problem4=(12, 4))
-
-    def test_after_max(self):
-        conf = ('commas:\n'
-                '  max-spaces-before: -1\n'
-                '  min-spaces-after: 0\n'
-                '  max-spaces-after: 1\n')
         self.check('---\n'
                    'array: [1, 2, 3, 4]\n'
                    '...\n', conf)
@@ -206,11 +124,8 @@ class CommaTestCase(RuleTestCase):
                    '  key1: val1,   key2: [val2,  val3]\n'
                    '}\n', conf, problem1=(3, 16), problem2=(3, 30))
 
-    def test_after_max_3(self):
+    def test_after_max(self):
-        conf = ('commas:\n'
+        conf = 'commas: {max-spaces-before: -1, max-spaces-after: 3}'
-                '  max-spaces-before: -1\n'
-                '  min-spaces-after: 1\n'
-                '  max-spaces-after: 3\n')
         self.check('---\n'
                    'array: [1,  2, 3,   4]\n'
                    '...\n', conf)
@@ -222,10 +137,7 @@ class CommaTestCase(RuleTestCase):
                    '...\n', conf, problem1=(2, 31), problem2=(2, 49))
 
     def test_both_before_and_after(self):
-        conf = ('commas:\n'
+        conf = 'commas: {max-spaces-before: 0, max-spaces-after: 1}'
-                '  max-spaces-before: 0\n'
-                '  min-spaces-after: 1\n'
-                '  max-spaces-after: 1\n')
         self.check('---\n'
                    'dict: {a: b ,   c: "1 2 3",    d: e , f: [g,      h]}\n'
                    'array: [\n'
@@ -240,25 +152,36 @@ class CommaTestCase(RuleTestCase):
                    problem1=(2, 12), problem2=(2, 16), problem3=(2, 31),
                    problem4=(2, 36), problem5=(2, 50), problem6=(4, 8),
                    problem7=(5, 11), problem8=(8, 13))
-        conf = ('commas:\n'
+
-                '  max-spaces-before: 0\n'
+    def test_comma_on_new_line(self):
-                '  min-spaces-after: 1\n'
+        conf = 'commas: {max-spaces-before: 0, max-spaces-after: 1}'
-                '  max-spaces-after: 1\n'
+        self.check('---\n'
+                   'flow-seq: [1, 2, 3\n'
+                   '           , 4, 5, 6]\n'
+                   '...\n', conf, problem=(3, 11))
+        self.check('---\n'
+                   'flow-map: {a: 1, b: 2\n'
+                   '           , c: 3}\n'
+                   '...\n', conf, problem=(3, 11))
+        conf = ('commas: {max-spaces-before: 0, max-spaces-after: 1}\n'
                 'indentation: disable\n')
         self.check('---\n'
-                   '- [one, two , three,four]\n'
+                   'flow-seq: [1, 2, 3\n'
-                   '- {five,six , seven, eight}\n'
+                   '         , 4, 5, 6]\n'
-                   '- [\n'
+                   '...\n', conf, problem=(3, 9))
-                   '  nine,  ten\n'
+        self.check('---\n'
-                   '  , eleven\n'
+                   'flow-map: {a: 1, b: 2\n'
-                   '  ,twelve\n'
+                   '         , c: 3}\n'
-                   ']\n'
+                   '...\n', conf, problem=(3, 9))
-                   '- {\n'
+        self.check('---\n'
-                   '  thirteen: 13,  fourteen\n'
+                   '[\n'
-                   '  , fifteen: 15\n'
+                   '1,\n'
-                   '  ,sixteen: 16\n'
+                   '2\n'
-                   '}\n', conf,
+                   ', 3\n'
-                   problem1=(2, 12), problem2=(2, 21), problem3=(3, 9),
+                   ']\n', conf, problem=(5, 1))
-                   problem4=(3, 12), problem5=(5, 9), problem6=(6, 2),
+        self.check('---\n'
-                   problem7=(7, 2), problem8=(7, 4), problem9=(10, 17),
+                   '{\n'
-                   problem10=(11, 2), problem11=(12, 2), problem12=(12, 4))
+                   'a: 1,\n'
+                   'b: 2\n'
+                   ', c: 3\n'
+                   '}\n', conf, problem=(5, 1))

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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class CommentsTestCase(RuleTestCase):
@@ -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,53 +126,8 @@ 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'
-                '  min-spaces-from-content: 2\n'
-                'trailing-spaces: disable\n')
-        self.check('---\n'
-                   'string: >\n'
-                   '  this is plain text\n'
-                   '\n'
-                   '# comment\n', conf)
-        self.check('---\n'
-                   '- string: >\n'
-                   '    this is plain text\n'
-                   '  \n'
-                   '  # comment\n', conf)

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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class CommentsIndentationTestCase(RuleTestCase):
@@ -48,7 +49,7 @@ class CommentsIndentationTestCase(RuleTestCase):
                    '...\n', conf)
 
     def test_enabled(self):
-        conf = 'comments-indentation: enable'
+        conf = 'comments-indentation: {}'
         self.check('---\n'
                    '# line 1\n'
                    '# line 2\n', conf)
@@ -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'
@@ -122,18 +123,18 @@ class CommentsIndentationTestCase(RuleTestCase):
                    '...\n', conf)
 
     def test_first_line(self):
-        conf = 'comments-indentation: enable'
+        conf = 'comments-indentation: {}'
         self.check('# comment\n', conf)
         self.check('  # comment\n', conf, problem=(1, 3))
 
     def test_no_newline_at_end(self):
-        conf = ('comments-indentation: enable\n'
+        conf = ('comments-indentation: {}\n'
                 'new-line-at-end-of-file: disable\n')
         self.check('# comment', conf)
         self.check('  # comment', conf, problem=(1, 3))
 
     def test_empty_comment(self):
-        conf = 'comments-indentation: enable'
+        conf = 'comments-indentation: {}'
         self.check('---\n'
                    '# hey\n'
                    '# normal\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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class DocumentEndTestCase(RuleTestCase):
@@ -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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class DocumentStartTestCase(RuleTestCase):
@@ -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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class EmptyLinesTestCase(RuleTestCase):
@@ -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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class HyphenTestCase(RuleTestCase):

tests/rules/test_key_duplicates.py

@@ -1,181 +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 KeyDuplicatesTestCase(RuleTestCase):
-    rule_id = 'key-duplicates'
-
-    def test_disabled(self):
-        conf = 'key-duplicates: disable'
-        self.check('---\n'
-                   'block mapping:\n'
-                   '  key: a\n'
-                   '  otherkey: b\n'
-                   '  key: c\n', conf)
-        self.check('---\n'
-                   'flow mapping:\n'
-                   '  {key: a, otherkey: b, key: c}\n', conf)
-        self.check('---\n'
-                   'duplicated twice:\n'
-                   '  - k: a\n'
-                   '    ok: b\n'
-                   '    k: c\n'
-                   '    k: d\n', conf)
-        self.check('---\n'
-                   'duplicated twice:\n'
-                   '  - {k: a, ok: b, k: c, k: d}\n', conf)
-        self.check('---\n'
-                   'multiple duplicates:\n'
-                   '  a: 1\n'
-                   '  b: 2\n'
-                   '  c: 3\n'
-                   '  d: 4\n'
-                   '  d: 5\n'
-                   '  b: 6\n', conf)
-        self.check('---\n'
-                   'multiple duplicates:\n'
-                   '  {a: 1, b: 2, c: 3, d: 4, d: 5, b: 6}\n', conf)
-        self.check('---\n'
-                   'at: root\n'
-                   'multiple: times\n'
-                   'at: root\n', conf)
-        self.check('---\n'
-                   'nested but OK:\n'
-                   '  a: {a: {a: 1}}\n'
-                   '  b:\n'
-                   '    b: 2\n'
-                   '    c: 3\n', conf)
-        self.check('---\n'
-                   'nested duplicates:\n'
-                   '  a: {a: 1, a: 1}\n'
-                   '  b:\n'
-                   '    c: 3\n'
-                   '    d: 4\n'
-                   '    d: 4\n'
-                   '  b: 2\n', conf)
-        self.check('---\n'
-                   'duplicates with many styles: 1\n'
-                   '"duplicates with many styles": 1\n'
-                   '\'duplicates with many styles\': 1\n'
-                   '? duplicates with many styles\n'
-                   ': 1\n'
-                   '? >-\n'
-                   '    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'
-        self.check('---\n'
-                   'block mapping:\n'
-                   '  key: a\n'
-                   '  otherkey: b\n'
-                   '  key: c\n', conf,
-                   problem=(5, 3))
-        self.check('---\n'
-                   'flow mapping:\n'
-                   '  {key: a, otherkey: b, key: c}\n', conf,
-                   problem=(3, 25))
-        self.check('---\n'
-                   'duplicated twice:\n'
-                   '  - k: a\n'
-                   '    ok: b\n'
-                   '    k: c\n'
-                   '    k: d\n', conf,
-                   problem1=(5, 5), problem2=(6, 5))
-        self.check('---\n'
-                   'duplicated twice:\n'
-                   '  - {k: a, ok: b, k: c, k: d}\n', conf,
-                   problem1=(3, 19), problem2=(3, 25))
-        self.check('---\n'
-                   'multiple duplicates:\n'
-                   '  a: 1\n'
-                   '  b: 2\n'
-                   '  c: 3\n'
-                   '  d: 4\n'
-                   '  d: 5\n'
-                   '  b: 6\n', conf,
-                   problem1=(7, 3), problem2=(8, 3))
-        self.check('---\n'
-                   'multiple duplicates:\n'
-                   '  {a: 1, b: 2, c: 3, d: 4, d: 5, b: 6}\n', conf,
-                   problem1=(3, 28), problem2=(3, 34))
-        self.check('---\n'
-                   'at: root\n'
-                   'multiple: times\n'
-                   'at: root\n', conf,
-                   problem=(4, 1))
-        self.check('---\n'
-                   'nested but OK:\n'
-                   '  a: {a: {a: 1}}\n'
-                   '  b:\n'
-                   '    b: 2\n'
-                   '    c: 3\n', conf)
-        self.check('---\n'
-                   'nested duplicates:\n'
-                   '  a: {a: 1, a: 1}\n'
-                   '  b:\n'
-                   '    c: 3\n'
-                   '    d: 4\n'
-                   '    d: 4\n'
-                   '  b: 2\n', conf,
-                   problem1=(3, 13), problem2=(7, 5), problem3=(8, 3))
-        self.check('---\n'
-                   'duplicates with many styles: 1\n'
-                   '"duplicates with many styles": 1\n'
-                   '\'duplicates with many styles\': 1\n'
-                   '? duplicates with many styles\n'
-                   ': 1\n'
-                   '? >-\n'
-                   '    duplicates with\n'
-                   '    many styles\n'
-                   ': 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'
-        self.check('---\n'
-                   '[\n'
-                   '  flow: sequence, with, key: value, mappings\n'
-                   ']\n', conf)

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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class LineLengthTestCase(RuleTestCase):
@@ -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'
@@ -45,17 +43,17 @@ class LineLengthTestCase(RuleTestCase):
         self.check('---\n', conf)
         self.check(80 * 'a', conf)
         self.check('---\n' + 80 * 'a' + '\n', conf)
-        self.check(16 * 'aaaa ' + 'z', conf, problem=(1, 81))
+        self.check(81 * 'a', conf, problem=(1, 81))
-        self.check('---\n' + 16 * 'aaaa ' + 'z' + '\n', conf, problem=(2, 81))
+        self.check('---\n' + 81 * 'a' + '\n', conf, problem=(2, 81))
-        self.check(1000 * 'word ' + 'end', conf, problem=(1, 81))
+        self.check(1000 * 'b', conf, problem=(1, 81))
-        self.check('---\n' + 1000 * 'word ' + 'end\n', conf, problem=(2, 81))
+        self.check('---\n' + 1000 * 'b' + '\n', conf, problem=(2, 81))
 
     def test_max_length_10(self):
         conf = ('line-length: {max: 10}\n'
                 'new-line-at-end-of-file: disable\n')
-        self.check('---\nABCD EFGHI', conf)
+        self.check('---\nABCDEFGHIJ', conf)
-        self.check('---\nABCD EFGHIJ', conf, problem=(2, 11))
+        self.check('---\nABCDEFGHIJK', conf, problem=(2, 11))
-        self.check('---\nABCD EFGHIJ\n', conf, problem=(2, 11))
+        self.check('---\nABCDEFGHIJK\n', conf, problem=(2, 11))
 
     def test_spaces(self):
         conf = ('line-length: {max: 80}\n'
@@ -63,136 +61,3 @@ class LineLengthTestCase(RuleTestCase):
                 'trailing-spaces: disable\n')
         self.check('---\n' + 81 * ' ', conf, problem=(2, 81))
         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}'
-        self.check('---\n' + 30 * 'A' + '\n', conf)
-        self.check('---\n'
-                   'this:\n'
-                   '  is:\n'
-                   '    - a:\n'
-                   '        http://localhost/very/long/url\n'
-                   '...\n', conf)
-        self.check('---\n'
-                   'this:\n'
-                   '  is:\n'
-                   '    - a:\n'
-                   '        # 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}'
-        self.check('---\n' + 30 * 'A' + '\n', conf, problem=(2, 21))
-        self.check('---\n'
-                   'this:\n'
-                   '  is:\n'
-                   '    - a:\n'
-                   '        http://localhost/very/long/url\n'
-                   '...\n', conf, problem=(5, 21))
-        self.check('---\n'
-                   'this:\n'
-                   '  is:\n'
-                   '    - a:\n'
-                   '        # 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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class NewLineAtEndOfFileTestCase(RuleTestCase):
@@ -29,7 +30,7 @@ class NewLineAtEndOfFileTestCase(RuleTestCase):
         self.check('Sentence.\n', conf)
 
     def test_enabled(self):
-        conf = ('new-line-at-end-of-file: enable\n'
+        conf = ('new-line-at-end-of-file: {}\n'
                 'empty-lines: disable\n'
                 'document-start: disable\n')
         self.check('', conf)

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,9 +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 unittest import mock
+from tests.rules.common import RuleTestCase
-
-from tests.common import RuleTestCase
 
 
 class NewLinesTestCase(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_syntax_error.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,13 +14,13 @@
 # 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 tests.rules.common import RuleTestCase
 
 
 class YamlLintTestCase(RuleTestCase):
     rule_id = None  # syntax error
 
-    def test_syntax_errors(self):
+    def test_lint(self):
         self.check('---\n'
                    'this is not: valid: YAML\n', None, problem=(2, 19))
         self.check('---\n'
@@ -28,21 +29,13 @@ class YamlLintTestCase(RuleTestCase):
                    'this is an error: [\n'
                    '\n'
                    '...\n', None, problem=(6, 1))
+
+    def test_directives(self):
         self.check('%YAML 1.2\n'
                    '%TAG ! tag:clarkevans.com,2002:\n'
                    'doc: ument\n'
                    '...\n', None, problem=(3, 1))
 
-    def test_empty_flows(self):
-        self.check('---\n'
-                   '- []\n'
-                   '- {}\n'
-                   '- [\n'
-                   ']\n'
-                   '- {\n'
-                   '}\n'
-                   '...\n', None)
-
     def test_explicit_mapping(self):
         self.check('---\n'
                    '? key\n'
@@ -74,20 +67,3 @@ class YamlLintTestCase(RuleTestCase):
                    '   Atlanta Braves]\n'
                    ': [2001-07-02, 2001-08-12,\n'
                    '   2001-08-14]\n', None)
-
-    def test_sets(self):
-        self.check('---\n'
-                   '? key one\n'
-                   '? key two\n'
-                   '? [non, scalar, key]\n'
-                   '? key with value\n'
-                   ': value\n'
-                   '...\n', None)
-        self.check('---\n'
-                   '? - multi\n'
-                   '  - line\n'
-                   '  - keys\n'
-                   '? in:\n'
-                   '    a:\n'
-                   '      set\n'
-                   '...\n', None)

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
@@ -13,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from tests.common import RuleTestCase
+from tests.rules.common import RuleTestCase
 
 
 class TrailingSpacesTestCase(RuleTestCase):
@@ -28,7 +29,7 @@ class TrailingSpacesTestCase(RuleTestCase):
                    'some: text \n', conf)
 
     def test_enabled(self):
-        conf = 'trailing-spaces: enable'
+        conf = 'trailing-spaces: {}'
         self.check('', conf)
         self.check('\n', conf)
         self.check('    \n', conf, problem=(1, 1))
@@ -39,7 +40,7 @@ class TrailingSpacesTestCase(RuleTestCase):
                    'some: text\t\n', conf, problem=(2, 11, 'syntax'))
 
     def test_with_dos_new_lines(self):
-        conf = ('trailing-spaces: enable\n'
+        conf = ('trailing-spaces: {}\n'
                 'new-lines: {type: dos}\n')
         self.check('---\r\n'
                    'some: text\r\n', conf)

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,797 +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 io import StringIO
-import fcntl
-import locale
-import os
-import pty
-import shutil
-import sys
-import tempfile
-import unittest
-
-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 setUpClass(cls):
-        super(CommandLineTestCase, cls).setUpClass()
-
-        cls.wd = build_temp_workspace({
-            # .yaml file at root
-            'a.yaml': '---\n'
-                      '- 1   \n'
-                      '- 2',
-            # file with only one warning
-            'warn.yaml': 'key: value\n',
-            # .yml file at root
-            'empty.yml': '',
-            # file in dir
-            'sub/ok.yaml': '---\n'
-                           'key: value\n',
-            # directory that looks like a yaml file
-            'sub/directory.yaml/not-yaml.txt': '',
-            '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'
-                                                       'key: value\n'
-                                                       'key: other value\n',
-            # empty dir
-            'empty-dir': [],
-            # non-YAML file
-            'no-yaml.json': '---\n'
-                            'key: value\n',
-            # non-ASCII chars
-            'non-ascii/éçäγλνπ¥/utf-8': (
-                '---\n'
-                '- hétérogénéité\n'
-                '# 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)),
-            [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')],
-        )
-
-        items = [os.path.join(self.wd, 'sub/ok.yaml'),
-                 os.path.join(self.wd, 'empty-dir')]
-        self.assertEqual(
-            sorted(cli.find_files_recursively(items, conf)),
-            [os.path.join(self.wd, 'sub/ok.yaml')],
-        )
-
-        items = [os.path.join(self.wd, 'empty.yml'),
-                 os.path.join(self.wd, 's')]
-        self.assertEqual(
-            sorted(cli.find_files_recursively(items, conf)),
-            [os.path.join(self.wd, 'empty.yml'),
-             os.path.join(self.wd, 's/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml')],
-        )
-
-        items = [os.path.join(self.wd, 'sub'),
-                 os.path.join(self.wd, '/etc/another/file')]
-        self.assertEqual(
-            sorted(cli.find_files_recursively(items, conf)),
-            [os.path.join(self.wd, '/etc/another/file'),
-             os.path.join(self.wd, 'sub/directory.yaml/empty.yml'),
-             os.path.join(self.wd, 'sub/ok.yaml')],
-        )
-
-        conf = config.YamlLintConfig('extends: default\n'
-                                     'yaml-files:\n'
-                                     '  - \'*.yaml\' \n')
-        self.assertEqual(
-            sorted(cli.find_files_recursively([self.wd], conf)),
-            [os.path.join(self.wd, 'a.yaml'),
-             os.path.join(self.wd, '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'
-                                     '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'
-                                     'yaml-files:\n'
-                                     '  - \'*.yaml\'\n'
-                                     '  - \'*\'\n'
-                                     '  - \'**\'\n')
-        self.assertEqual(
-            sorted(cli.find_files_recursively([self.wd], conf)),
-            [os.path.join(self.wd, 'a.yaml'),
-             os.path.join(self.wd, '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'
-                                     'yaml-files:\n'
-                                     '  - \'s/**\'\n'
-                                     '  - \'**/utf-8\'\n')
-        self.assertEqual(
-            sorted(cli.find_files_recursively([self.wd], conf)),
-            [os.path.join(self.wd, 'non-ascii/éçäγλνπ¥/utf-8')]
-        )
-
-    def test_run_with_bad_arguments(self):
-        with RunContext(self) as ctx:
-            cli.run(())
-        self.assertNotEqual(ctx.returncode, 0)
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(ctx.stderr, r'^usage')
-
-        with RunContext(self) as ctx:
-            cli.run(('--unknown-arg', ))
-        self.assertNotEqual(ctx.returncode, 0)
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(ctx.stderr, r'^usage')
-
-        with RunContext(self) as ctx:
-            cli.run(('-c', './conf.yaml', '-d', 'relaxed', 'file'))
-        self.assertNotEqual(ctx.returncode, 0)
-        self.assertEqual(ctx.stdout, '')
-        self.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
-        with RunContext(self) as ctx:
-            cli.run(('-', 'file'))
-        self.assertNotEqual(ctx.returncode, 0)
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(ctx.stderr, r'^usage')
-
-    def test_run_with_bad_config(self):
-        with RunContext(self) as ctx:
-            cli.run(('-d', 'rules: {a: b}', 'file'))
-        self.assertEqual(ctx.returncode, -1)
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(ctx.stderr, r'^invalid config: no such rule')
-
-    def test_run_with_empty_config(self):
-        with RunContext(self) as ctx:
-            cli.run(('-d', '', 'file'))
-        self.assertEqual(ctx.returncode, -1)
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(ctx.stderr, r'^invalid config: not a dict')
-
-    def test_run_with_implicit_extends_config(self):
-        path = os.path.join(self.wd, 'warn.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run(('-d', 'default', '-f', 'parsable', path))
-        expected_out = ('%s:1:1: [warning] missing document start "---" '
-                        '(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:
-            cli.run(('--version', ))
-        self.assertEqual(ctx.returncode, 0)
-        self.assertRegex(ctx.stdout + ctx.stderr, r'yamllint \d+\.\d+')
-
-    def test_run_non_existing_file(self):
-        path = os.path.join(self.wd, 'i-do-not-exist.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run(('-f', 'parsable', path))
-        self.assertEqual(ctx.returncode, -1)
-        self.assertEqual(ctx.stdout, '')
-        self.assertRegex(ctx.stderr, r'No such file or directory')
-
-    def test_run_one_problem_file(self):
-        path = os.path.join(self.wd, 'a.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run(('-f', 'parsable', path))
-        self.assertEqual(ctx.returncode, 1)
-        self.assertEqual(ctx.stdout, (
-            '%s:2:4: [error] trailing spaces (trailing-spaces)\n'
-            '%s:3:4: [error] no new line character at the end of file '
-            '(new-line-at-end-of-file)\n' % (path, path)))
-        self.assertEqual(ctx.stderr, '')
-
-    def test_run_one_warning(self):
-        path = os.path.join(self.wd, 'warn.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run(('-f', 'parsable', path))
-        self.assertEqual(ctx.returncode, 0)
-
-    def test_run_warning_in_strict_mode(self):
-        path = os.path.join(self.wd, 'warn.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run(('-f', 'parsable', '--strict', path))
-        self.assertEqual(ctx.returncode, 2)
-
-    def test_run_one_ok_file(self):
-        path = os.path.join(self.wd, 'sub', 'ok.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run(('-f', 'parsable', path))
-        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
-
-    def test_run_empty_file(self):
-        path = os.path.join(self.wd, 'empty.yml')
-
-        with RunContext(self) as ctx:
-            cli.run(('-f', 'parsable', path))
-        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
-
-    @unittest.skipIf(not utf8_available(), 'C.UTF-8 not available')
-    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')
-        with RunContext(self) as ctx:
-            cli.run(('-f', 'parsable', path))
-        self.assertEqual((ctx.returncode, ctx.stdout, ctx.stderr), (0, '', ''))
-
-    def test_run_multiple_files(self):
-        items = [os.path.join(self.wd, 'empty.yml'),
-                 os.path.join(self.wd, 's')]
-        path = items[1] + '/s/s/s/s/s/s/s/s/s/s/s/s/s/s/file.yaml'
-
-        with RunContext(self) as ctx:
-            cli.run(['-f', 'parsable'] + items)
-        self.assertEqual((ctx.returncode, ctx.stderr), (1, ''))
-        self.assertEqual(ctx.stdout, (
-            '%s:3:1: [error] duplication of key "key" in mapping '
-            '(key-duplicates)\n') % path)
-
-    def test_run_piped_output_nocolor(self):
-        path = os.path.join(self.wd, 'a.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run((path, ))
-        self.assertEqual((ctx.returncode, ctx.stderr), (1, ''))
-        self.assertEqual(ctx.stdout, (
-            '%s\n'
-            '  2:4       error    trailing spaces  (trailing-spaces)\n'
-            '  3:4       error    no new line character at the end of file  '
-            '(new-line-at-end-of-file)\n'
-            '\n' % path))
-
-    def test_run_default_format_output_in_tty(self):
-        path = os.path.join(self.wd, 'a.yaml')
-
-        # Create a pseudo-TTY and redirect stdout to it
-        master, slave = pty.openpty()
-        sys.stdout = sys.stderr = os.fdopen(slave, 'w')
-
-        with self.assertRaises(SystemExit) as ctx:
-            cli.run((path, ))
-        sys.stdout.flush()
-
-        self.assertEqual(ctx.exception.code, 1)
-
-        # Read output from TTY
-        output = os.fdopen(master, 'r')
-        flag = fcntl.fcntl(master, fcntl.F_GETFD)
-        fcntl.fcntl(master, fcntl.F_SETFL, flag | os.O_NONBLOCK)
-
-        out = output.read().replace('\r\n', '\n')
-
-        sys.stdout.close()
-        sys.stderr.close()
-        output.close()
-
-        self.assertEqual(out, (
-            '\033[4m%s\033[0m\n'
-            '  \033[2m2:4\033[0m       \033[31merror\033[0m    '
-            'trailing spaces  \033[2m(trailing-spaces)\033[0m\n'
-            '  \033[2m3:4\033[0m       \033[31merror\033[0m    '
-            'no new line character at the end of file  '
-            '\033[2m(new-line-at-end-of-file)\033[0m\n'
-            '\n' % path))
-
-    def test_run_default_format_output_without_tty(self):
-        path = os.path.join(self.wd, 'a.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run((path, ))
-        expected_out = (
-            '%s\n'
-            '  2:4       error    trailing spaces  (trailing-spaces)\n'
-            '  3:4       error    no new line character at the end of file  '
-            '(new-line-at-end-of-file)\n'
-            '\n' % path)
-        self.assertEqual(
-            (ctx.returncode, ctx.stdout, ctx.stderr), (1, expected_out, ''))
-
-    def test_run_auto_output_without_tty_output(self):
-        path = os.path.join(self.wd, 'a.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run((path, '--format', 'auto'))
-        expected_out = (
-            '%s\n'
-            '  2:4       error    trailing spaces  (trailing-spaces)\n'
-            '  3:4       error    no new line character at the end of file  '
-            '(new-line-at-end-of-file)\n'
-            '\n' % path)
-        self.assertEqual(
-            (ctx.returncode, ctx.stdout, ctx.stderr), (1, expected_out, ''))
-
-    def test_run_format_colored(self):
-        path = os.path.join(self.wd, 'a.yaml')
-
-        with RunContext(self) as ctx:
-            cli.run((path, '--format', 'colored'))
-        expected_out = (
-            '\033[4m%s\033[0m\n'
-            '  \033[2m2:4\033[0m       \033[31merror\033[0m    '
-            'trailing spaces  \033[2m(trailing-spaces)\033[0m\n'
-            '  \033[2m3:4\033[0m       \033[31merror\033[0m    '
-            'no new line character at the end of file  '
-            '\033[2m(new-line-at-end-of-file)\033[0m\n'
-            '\n' % path)
-        self.assertEqual(
-            (ctx.returncode, ctx.stdout, ctx.stderr), (1, expected_out, ''))
-
-    def test_run_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,751 +14,56 @@
 # 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
 
 
-class SimpleConfigTestCase(unittest.TestCase):
+class ConfigTestCase(unittest.TestCase):
-    def test_parse_config(self):
+    def setUp(self):
-        new = config.YamlLintConfig('rules:\n'
+        self.base = config.parse_config_from_file(os.path.join(
-                                    '  colons:\n'
+            os.path.dirname(os.path.dirname(os.path.realpath(__file__))),
-                                    '    max-spaces-before: 0\n'
+            'yamllint', 'conf', 'default.yml'))
-                                    '    max-spaces-after: 1\n')
-
-        self.assertEqual(list(new.rules.keys()), ['colons'])
-        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)
-
-    def test_invalid_conf(self):
-        with self.assertRaises(config.YamlLintConfigError):
-            config.YamlLintConfig('not: valid: yaml')
-
-    def test_unknown_rule(self):
-        with self.assertRaisesRegex(
-                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'
-                                  '  colons: enable\n')
-        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
-        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
-
-        c = config.YamlLintConfig('rules:\n'
-                                  '  colons:\n'
-                                  '    max-spaces-before: 9\n')
-        self.assertEqual(c.rules['colons']['max-spaces-before'], 9)
-        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
-
-    def test_unknown_option(self):
-        with self.assertRaisesRegex(
-                config.YamlLintConfigError,
-                'invalid config: unknown option "abcdef" for rule "colons"'):
-            config.YamlLintConfig('rules:\n'
-                                  '  colons:\n'
-                                  '    max-spaces-before: 0\n'
-                                  '    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:
-            ID = 'fake'
-
-        self.assertFalse(config.validate_rule_conf(Rule, False))
-        self.assertEqual(config.validate_rule_conf(Rule, {}),
-                         {'level': 'error'})
-
-        config.validate_rule_conf(Rule, {'level': 'error'})
-        config.validate_rule_conf(Rule, {'level': 'warning'})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule, {'level': 'warn'})
-
-        Rule.CONF = {'length': int}
-        Rule.DEFAULT = {'length': 80}
-        config.validate_rule_conf(Rule, {'length': 8})
-        config.validate_rule_conf(Rule, {})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule, {'height': 8})
-
-        Rule.CONF = {'a': bool, 'b': int}
-        Rule.DEFAULT = {'a': True, 'b': -42}
-        config.validate_rule_conf(Rule, {'a': True, 'b': 0})
-        config.validate_rule_conf(Rule, {'a': True})
-        config.validate_rule_conf(Rule, {'b': 0})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule, {'a': 1, 'b': 0})
-
-        Rule.CONF = {'choice': (True, 88, 'str')}
-        Rule.DEFAULT = {'choice': 88}
-        config.validate_rule_conf(Rule, {'choice': True})
-        config.validate_rule_conf(Rule, {'choice': 88})
-        config.validate_rule_conf(Rule, {'choice': 'str'})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule, {'choice': False})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule, {'choice': 99})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule, {'choice': 'abc'})
-
-        Rule.CONF = {'choice': (int, 'hardcoded')}
-        Rule.DEFAULT = {'choice': 1337}
-        config.validate_rule_conf(Rule, {'choice': 42})
-        config.validate_rule_conf(Rule, {'choice': 'hardcoded'})
-        config.validate_rule_conf(Rule, {})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule, {'choice': False})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule, {'choice': 'abc'})
-
-        Rule.CONF = {'multiple': ['item1', 'item2', 'item3']}
-        Rule.DEFAULT = {'multiple': ['item1']}
-        config.validate_rule_conf(Rule, {'multiple': []})
-        config.validate_rule_conf(Rule, {'multiple': ['item2']})
-        config.validate_rule_conf(Rule, {'multiple': ['item2', 'item3']})
-        config.validate_rule_conf(Rule, {})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule,
-                          {'multiple': 'item1'})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule,
-                          {'multiple': ['']})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule,
-                          {'multiple': ['item1', 4]})
-        self.assertRaises(config.YamlLintConfigError,
-                          config.validate_rule_conf, Rule,
-                          {'multiple': ['item4']})
-
-    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):
-        old = config.YamlLintConfig('rules:\n'
-                                    '  colons:\n'
-                                    '    max-spaces-before: 0\n'
-                                    '    max-spaces-after: 1\n')
-        new = config.YamlLintConfig('rules:\n'
-                                    '  hyphens:\n'
-                                    '    max-spaces-after: 2\n')
-        new.extend(old)
-
-        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(new.rules['colons']['max-spaces-before'], 0)
-        self.assertEqual(new.rules['colons']['max-spaces-after'], 1)
-        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
-
-        self.assertEqual(len(new.enabled_rules(None)), 2)
-
-    def test_extend_on_file(self):
-        with tempfile.NamedTemporaryFile('w') as f:
-            f.write('rules:\n'
-                    '  colons:\n'
-                    '    max-spaces-before: 0\n'
-                    '    max-spaces-after: 1\n')
-            f.flush()
-            c = config.YamlLintConfig('extends: ' + f.name + '\n'
-                                      'rules:\n'
-                                      '  hyphens:\n'
-                                      '    max-spaces-after: 2\n')
-
-        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(c.rules['colons']['max-spaces-before'], 0)
-        self.assertEqual(c.rules['colons']['max-spaces-after'], 1)
-        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
-
-        self.assertEqual(len(c.enabled_rules(None)), 2)
-
-    def test_extend_remove_rule(self):
-        with tempfile.NamedTemporaryFile('w') as f:
-            f.write('rules:\n'
-                    '  colons:\n'
-                    '    max-spaces-before: 0\n'
-                    '    max-spaces-after: 1\n'
-                    '  hyphens:\n'
-                    '    max-spaces-after: 2\n')
-            f.flush()
-            c = config.YamlLintConfig('extends: ' + f.name + '\n'
-                                      'rules:\n'
-                                      '  colons: disable\n')
-
-        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
-        self.assertFalse(c.rules['colons'])
-        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
-
-        self.assertEqual(len(c.enabled_rules(None)), 1)
-
-    def test_extend_edit_rule(self):
-        with tempfile.NamedTemporaryFile('w') as f:
-            f.write('rules:\n'
-                    '  colons:\n'
-                    '    max-spaces-before: 0\n'
-                    '    max-spaces-after: 1\n'
-                    '  hyphens:\n'
-                    '    max-spaces-after: 2\n')
-            f.flush()
-            c = config.YamlLintConfig('extends: ' + f.name + '\n'
-                                      'rules:\n'
-                                      '  colons:\n'
-                                      '    max-spaces-before: 3\n'
-                                      '    max-spaces-after: 4\n')
-
-        self.assertEqual(sorted(c.rules.keys()), ['colons', 'hyphens'])
-        self.assertEqual(c.rules['colons']['max-spaces-before'], 3)
-        self.assertEqual(c.rules['colons']['max-spaces-after'], 4)
-        self.assertEqual(c.rules['hyphens']['max-spaces-after'], 2)
-
-        self.assertEqual(len(c.enabled_rules(None)), 2)
-
-    def test_extend_reenable_rule(self):
-        with tempfile.NamedTemporaryFile('w') as f:
-            f.write('rules:\n'
-                    '  colons:\n'
-                    '    max-spaces-before: 0\n'
-                    '    max-spaces-after: 1\n'
-                    '  hyphens: disable\n')
-            f.flush()
-            c = config.YamlLintConfig('extends: ' + f.name + '\n'
-                                      'rules:\n'
-                                      '  hyphens:\n'
-                                      '    max-spaces-after: 2\n')
-
-        self.assertEqual(sorted(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_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(c.ignore.match_file('test.yaml'), False)
-
-
-class ExtendedLibraryConfigTestCase(unittest.TestCase):
     def test_extend_config_disable_rule(self):
-        old = config.YamlLintConfig('extends: default')
+        new = config.parse_config('extends: default\n'
-        new = config.YamlLintConfig('extends: default\n'
+                                  'rules:\n'
-                                    'rules:\n'
+                                  '  trailing-spaces: disable\n')
-                                    '  trailing-spaces: disable\n')
 
-        old.rules['trailing-spaces'] = False
+        base = self.base.copy()
+        del base['trailing-spaces']
 
-        self.assertEqual(sorted(new.rules.keys()), sorted(old.rules.keys()))
+        self.assertEqual(sorted(new.keys()), sorted(base.keys()))
-        for rule in new.rules:
+        for rule in new:
-            self.assertEqual(new.rules[rule], old.rules[rule])
+            self.assertEqual(new[rule], base[rule])
 
     def test_extend_config_override_whole_rule(self):
-        old = config.YamlLintConfig('extends: default')
+        new = config.parse_config('extends: default\n'
-        new = config.YamlLintConfig('extends: default\n'
+                                  'rules:\n'
-                                    'rules:\n'
+                                  '  empty-lines:\n'
-                                    '  empty-lines:\n'
+                                  '    max: 42\n'
-                                    '    max: 42\n'
+                                  '    max-start: 43\n'
-                                    '    max-start: 43\n'
+                                  '    max-end: 44\n')
-                                    '    max-end: 44\n')
+
-
+        base = self.base.copy()
-        old.rules['empty-lines']['max'] = 42
+        base['empty-lines']['max'] = 42
-        old.rules['empty-lines']['max-start'] = 43
+        base['empty-lines']['max-start'] = 43
-        old.rules['empty-lines']['max-end'] = 44
+        base['empty-lines']['max-end'] = 44
-
+
-        self.assertEqual(sorted(new.rules.keys()), sorted(old.rules.keys()))
+        self.assertEqual(sorted(new.keys()), sorted(base.keys()))
-        for rule in new.rules:
+        for rule in new:
-            self.assertEqual(new.rules[rule], old.rules[rule])
+            self.assertEqual(new[rule], base[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')
+        new = config.parse_config('extends: default\n'
-        new = config.YamlLintConfig('extends: default\n'
+                                  'rules:\n'
-                                    'rules:\n'
+                                  '  empty-lines:\n'
-                                    '  empty-lines:\n'
+                                  '    max-start: 42\n')
-                                    '    max-start: 42\n')
-
-        old.rules['empty-lines']['max-start'] = 42
-
-        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)'
+        base = self.base.copy()
-        keydup = '[error] duplication of key "key" in mapping (key-duplicates)'
+        base['empty-lines']['max-start'] = 42
-        trailing = '[error] trailing spaces (trailing-spaces)'
-        hyphen = '[error] too many spaces after hyphen (hyphens)'
 
-        self.assertEqual(out, '\n'.join((
+        self.assertEqual(sorted(new.keys()), sorted(base.keys()))
-            './.yamllint:1:1: ' + docstart,
+        for rule in new:
-            './bin/file.lint-me-anyway.yaml:3:3: ' + keydup,
+            self.assertEqual(new[rule], base[rule])
-            './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,66 +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 io
-import unittest
-
-from yamllint.config import YamlLintConfig
-from yamllint import linter
-
-
-class LinterTestCase(unittest.TestCase):
-    def fake_config(self):
-        return YamlLintConfig('extends: default')
-
-    def test_run_on_string(self):
-        linter.run('test: document', self.fake_config())
-
-    def test_run_on_bytes(self):
-        linter.run(b'test: document', self.fake_config())
-
-    def test_run_on_unicode(self):
-        linter.run('test: document', self.fake_config())
-
-    def test_run_on_stream(self):
-        linter.run(io.StringIO('hello'), self.fake_config())
-
-    def test_run_on_int(self):
-        self.assertRaises(TypeError, linter.run, 42, self.fake_config())
-
-    def test_run_on_list(self):
-        self.assertRaises(TypeError, linter.run,
-                          ['h', 'e', 'l', 'l', 'o'], self.fake_config())
-
-    def test_run_on_non_ascii_chars(self):
-        s = ('- 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,92 +61,33 @@ 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.assertTrue(isinstance(e[0].curr, yaml.Token))
-        self.assertIsInstance(e[0].next, yaml.Token)
+        self.assertTrue(isinstance(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'))
+                                 'k: v\n'))
         self.assertEqual(len(e), 9)
-        self.assertIsInstance(e[3].curr, yaml.KeyToken)
+        self.assertTrue(isinstance(e[3].curr, yaml.KeyToken))
-        self.assertIsInstance(e[5].curr, yaml.ValueToken)
+        self.assertTrue(isinstance(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'
+        self.assertTrue(isinstance(e[0], Token))
-                                            '# comment\n'
+        self.assertTrue(isinstance(e[0].curr, yaml.StreamStartToken))
-                                            '- c\n'
+        self.assertTrue(isinstance(e[1], Token))
-                                            '# end comment\n'))
+        self.assertTrue(isinstance(e[1].curr, yaml.DocumentStartToken))
-        self.assertEqual(len(e), 21)
+        self.assertTrue(isinstance(e[2], Line))
-        self.assertIsInstance(e[1], Comment)
+        self.assertTrue(isinstance(e[3].curr, yaml.BlockMappingStartToken))
-        self.assertEqual(e[1], Comment(1, 1, '# start comment', 0))
+        self.assertTrue(isinstance(e[4].curr, yaml.KeyToken))
-        self.assertEqual(e[11], Comment(3, 13, '# key=val', 0))
+        self.assertTrue(isinstance(e[6].curr, yaml.ValueToken))
-        self.assertEqual(e[12], Comment(4, 1, '# this is', 0))
+        self.assertTrue(isinstance(e[8], Line))
-        self.assertEqual(e[13], Comment(5, 1, '# a block     ', 0))
+        self.assertTrue(isinstance(e[11], Line))
-        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)
-        self.assertIsInstance(e[1].curr, yaml.DocumentStartToken)
-        self.assertIsInstance(e[2], Line)
-        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[9], Line)
-        self.assertIsInstance(e[12], Line)

tests/test_spec_examples.py

@@ -1,188 +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 os
-
-from tests.common import RuleTestCase
-
-
-# This file checks examples from YAML 1.2 specification [1] against yamllint.
-#
-# [1]: http://www.yaml.org/spec/1.2/spec.html
-#
-# Example files generated with:
-#
-#     from bs4 import BeautifulSoup
-#     with open('spec.html', encoding='iso-8859-1') as f:
-#         soup = BeautifulSoup(f, 'lxml')
-#         for ex in soup.find_all('div', class_='example'):
-#             title = ex.find('p', class_='title').find('b').get_text()
-#             id = '-'.join(title.split('\xa0')[:2])[:-1].lower()
-#             span = ex.find('span', class_='database')
-#             for br in span.find_all("br"):
-#                 br.replace_with("\n")
-#             text = text.replace('\u2193', '')    # downwards arrow
-#             text = text.replace('\u21d3', '')    # double downwards arrow
-#             text = text.replace('\u00b7', ' ')   # visible space
-#             text = text.replace('\u21d4', '')    # byte order mark
-#             text = text.replace('\u2192', '\t')  # right arrow
-#             text = text.replace('\u00b0', '')    # empty scalar
-#             with open('tests/yaml-1.2-spec-examples/%s' % id, 'w',
-#                       encoding='utf-8') as g:
-#                 g.write(text)
-
-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.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'),
-    'example-2.6': ('braces: {min-spaces-inside: 0, max-spaces-inside: 0}\n'
-                    'indentation: disable\n'),
-    'example-2.12': ('empty-lines: {max-end: 1}\n'
-                     'colons: {max-spaces-before: -1}\n'),
-    'example-2.16': 'empty-lines: {max-end: 1}\n',
-    'example-2.18': 'empty-lines: {max-end: 1}\n',
-    'example-2.19': 'empty-lines: {max-end: 1}\n',
-    'example-2.28': 'empty-lines: {max-end: 3}\n',
-    'example-5.3': ('indentation: {indent-sequences: false}\n'
-                    'colons: {max-spaces-before: 1}\n'),
-    'example-6.4': 'trailing-spaces: disable\n',
-    'example-6.5': 'trailing-spaces: disable\n',
-    'example-6.6': 'trailing-spaces: disable\n',
-    'example-6.7': 'trailing-spaces: disable\n',
-    'example-6.8': 'trailing-spaces: disable\n',
-    'example-6.10': ('empty-lines: {max-end: 2}\n'
-                     'trailing-spaces: disable\n'
-                     'comments-indentation: disable\n'),
-    'example-6.11': ('empty-lines: {max-end: 1}\n'
-                     'comments-indentation: disable\n'),
-    'example-6.13': 'comments-indentation: disable\n',
-    'example-6.14': 'comments-indentation: disable\n',
-    'example-6.23': 'colons: {max-spaces-before: 1}\n',
-    'example-7.4': ('colons: {max-spaces-before: 1}\n'
-                    'indentation: disable\n'),
-    'example-7.5': 'trailing-spaces: disable\n',
-    'example-7.6': 'trailing-spaces: disable\n',
-    'example-7.7': 'indentation: disable\n',
-    'example-7.8': ('colons: {max-spaces-before: 1}\n'
-                    'indentation: 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.15': ('braces: {min-spaces-inside: 0, max-spaces-inside: 1}\n'
-                     'commas: {max-spaces-before: 1, min-spaces-after: 0}\n'
-                     'colons: {max-spaces-before: 1}\n'),
-    'example-7.16': 'indentation: disable\n',
-    'example-7.17': 'indentation: disable\n',
-    'example-7.18': 'indentation: disable\n',
-    'example-7.19': 'indentation: disable\n',
-    'example-7.20': ('colons: {max-spaces-before: 1}\n'
-                     'indentation: disable\n'),
-    'example-8.1': 'empty-lines: {max-end: 1}\n',
-    'example-8.2': 'trailing-spaces: disable\n',
-    'example-8.5': ('comments-indentation: disable\n'
-                    'trailing-spaces: disable\n'),
-    'example-8.6': 'empty-lines: {max-end: 1}\n',
-    'example-8.7': 'empty-lines: {max-end: 1}\n',
-    'example-8.8': 'trailing-spaces: disable\n',
-    'example-8.9': 'empty-lines: {max-end: 1}\n',
-    'example-8.14': 'colons: {max-spaces-before: 1}\n',
-    'example-8.16': 'indentation: {spaces: 1}\n',
-    'example-8.17': 'indentation: disable\n',
-    'example-8.20': ('indentation: {indent-sequences: false}\n'
-                     'colons: {max-spaces-before: 1}\n'),
-    'example-8.22': 'indentation: disable\n',
-    'example-10.1': 'colons: {max-spaces-before: 2}\n',
-    'example-10.2': 'indentation: {indent-sequences: false}\n',
-    'example-10.8': 'truthy: disable\n',
-    'example-10.9': 'truthy: disable\n',
-}
-
-files = os.listdir(os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                'yaml-1.2-spec-examples'))
-assert len(files) == 132
-
-
-def _gen_test(buffer, conf):
-    def test(self):
-        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()).
-pyyaml_blacklist = (
-    'example-2.11',
-    'example-2.23',
-    'example-2.24',
-    'example-2.27',
-    'example-5.10',
-    'example-5.12',
-    'example-5.13',
-    'example-5.14',
-    'example-5.6',
-    'example-6.1',
-    'example-6.12',
-    'example-6.15',
-    'example-6.17',
-    'example-6.18',
-    'example-6.19',
-    'example-6.2',
-    'example-6.20',
-    'example-6.21',
-    'example-6.22',
-    'example-6.24',
-    'example-6.25',
-    'example-6.26',
-    'example-6.27',
-    'example-6.3',
-    'example-7.1',
-    'example-7.10',
-    'example-7.12',
-    'example-7.17',
-    'example-7.2',
-    'example-7.21',
-    'example-7.22',
-    'example-7.3',
-    'example-8.18',
-    'example-8.19',
-    'example-8.21',
-    'example-8.3',
-    'example-9.3',
-    'example-9.4',
-    'example-9.5',
-)
-
-for file in files:
-    if file in pyyaml_blacklist:
-        continue
-
-    with open('tests/yaml-1.2-spec-examples/' + file, encoding='utf-8') as f:
-        conf = conf_general + conf_overrides.get(file, '')
-        setattr(SpecificationTestCase, 'test_' + file,
-                _gen_test(f.read(), conf))

tests/test_yamllint_directives.py

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

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

@@ -1,6 +0,0 @@
-Block style: !!map
-  Clark : Evans
-  Ingy  : döt Net
-  Oren  : Ben-Kiki
-
-Flow style: !!map { Clark: Evans, Ingy: döt Net, Oren: Ben-Kiki }

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

@@ -1,6 +0,0 @@
-Block style: !!seq
-- Clark Evans
-- Ingy döt Net
-- Oren Ben-Kiki
-
-Flow style: !!seq [ Clark Evans, Ingy döt Net, Oren Ben-Kiki ]

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

@@ -1,4 +0,0 @@
-Block style: !!str |-
-  String: just a theory.
-
-Flow style: !!str "String: just a theory."

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

@@ -1,2 +0,0 @@
-!!null null: value for null key
-key with null value: !!null null

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

@@ -1,2 +0,0 @@
-YAML is a superset of JSON: !!bool true
-Pluto is a planet: !!bool false

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

@@ -1,3 +0,0 @@
-negative: !!int -12
-zero: !!int 0
-positive: !!int 34

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

@@ -1,5 +0,0 @@
-negative: !!float -1
-zero: !!float 0
-positive: !!float 2.3e4
-infinity: !!float .inf
-not a number: !!float .nan

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

@@ -1,5 +0,0 @@
-A null: null
-Booleans: [ true, false ]
-Integers: [ 0, -0, 3, -19 ]
-Floats: [ 0., -0.0, 12e03, -2E+05 ]
-Invalid: [ True, Null, 0o7, 0x3A, +12.3 ]

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

@@ -1,7 +0,0 @@
-A null: null
-Also a null: # Empty
-Not a null: ""
-Booleans: [ true, True, false, FALSE ]
-Integers: [ 0, 0o7, 0x3A, -19 ]
-Floats: [ 0., -0.0, .5, +12e03, -2E+05 ]
-Also floats: [ .inf, -.Inf, +.INF, .NAN ]

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

@@ -1,3 +0,0 @@
-- Mark McGwire
-- Sammy Sosa
-- Ken Griffey

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

@@ -1,8 +0,0 @@
----
-hr:
-  - Mark McGwire
-  # Following node labeled SS
-  - &SS Sammy Sosa
-rbi:
-  - *SS # Subsequent occurrence
-  - Ken Griffey

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

@@ -1,9 +0,0 @@
-? - Detroit Tigers
-  - Chicago cubs
-:
-  - 2001-07-23
-
-? [ New York Yankees,
-    Atlanta Braves ]
-: [ 2001-07-02, 2001-08-12,
-    2001-08-14 ]

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

@@ -1,9 +0,0 @@
----
-# Products purchased
-- item    : Super Hoop
-  quantity: 1
-- item    : Basketball
-  quantity: 4
-- item    : Big Shoes
-  quantity: 1
-

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

@@ -1,4 +0,0 @@
-# ASCII Art
---- |
-  \//||\/||
-  // ||  ||__

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

@@ -1,4 +0,0 @@
---- >
-  Mark McGwire's
-  year was crippled
-  by a knee injury.

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

@@ -1,8 +0,0 @@
->
- Sammy Sosa completed another
- fine season with great stats.
-
-   63 Home Runs
-   0.288 Batting Average
-
- What a year!

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

@@ -1,8 +0,0 @@
-name: Mark McGwire
-accomplishment: >
-  Mark set a major league
-  home run record in 1998.
-stats: |
-  65 Home Runs
-  0.278 Batting Average
-

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

@@ -1,7 +0,0 @@
-unicode: "Sosa did fine.\u263A"
-control: "\b1998\t1999\t2000\n"
-hex esc: "\x0d\x0a is \r\n"
-
-single: '"Howdy!" he cried.'
-quoted: ' # Not a ''comment''.'
-tie-fighter: '|\-*-/|'

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

@@ -1,7 +0,0 @@
-plain:
-  This unquoted scalar
-  spans many lines.
-
-quoted: "So does this
-  quoted scalar.\n"
-

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

@@ -1,5 +0,0 @@
-canonical: 12345
-decimal: +12345
-octal: 0o14
-hexadecimal: 0xC
-

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

@@ -1,3 +0,0 @@
-hr:  65    # Home runs
-avg: 0.278 # Batting average
-rbi: 147   # Runs Batted In

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

@@ -1,5 +0,0 @@
-canonical: 1.23015e+3
-exponential: 12.3015e+02
-fixed: 1230.15
-negative infinity: -.inf
-not a number: .NaN

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

@@ -1,3 +0,0 @@
-null:
-booleans: [ true, false ]
-string: '012345'

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

@@ -1,4 +0,0 @@
-canonical: 2001-12-15T02:59:43.1Z
-iso8601: 2001-12-14t21:59:43.10-05:00
-spaced: 2001-12-14 21:59:43.10 -5
-date: 2002-12-14

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

@@ -1,14 +0,0 @@
----
-not-date: !!str 2002-04-28
-
-picture: !!binary |
- R0lGODlhDAAMAIQAAP//9/X
- 17unp5WZmZgAAAOfn515eXv
- Pz7Y6OjuDg4J+fn5OTk6enp
- 56enmleECcgggoBADs=
-
-application specific tag: !something |
- The semantics of the tag
- above may be different for
- different documents.
-

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

@@ -1,14 +0,0 @@
-%TAG ! tag:clarkevans.com,2002:
---- !shape
-  # Use the ! handle for presenting
-  # tag:clarkevans.com,2002:circle
-- !circle
-  center: &ORIGIN {x: 73, y: 129}
-  radius: 7
-- !line
-  start: *ORIGIN
-  finish: { x: 89, y: 102 }
-- !label
-  start: *ORIGIN
-  color: 0xFFEEBB
-  text: Pretty vector drawing.

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

@@ -1,7 +0,0 @@
-# Sets are represented as a
-# Mapping where each key is
-# associated with a null value
---- !!set
-? Mark McGwire
-? Sammy Sosa
-? Ken Griff

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

@@ -1,7 +0,0 @@
-# Ordered maps are represented as
-# A sequence of mappings, with
-# each mapping having one key
---- !!omap
-- Mark McGwire: 65
-- Sammy Sosa: 63
-- Ken Griffy: 58

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

@@ -1,29 +0,0 @@
---- !<tag:clarkevans.com,2002:invoice>
-invoice: 34843
-date   : 2001-01-23
-bill-to: &id001
-    given  : Chris
-    family : Dumars
-    address:
-        lines: |
-            458 Walkman Dr.
-            Suite #292
-        city    : Royal Oak
-        state   : MI
-        postal  : 48046
-ship-to: *id001
-product:
-    - sku         : BL394D
-      quantity    : 4
-      description : Basketball
-      price       : 450.00
-    - sku         : BL4438H
-      quantity    : 1
-      description : Super Hoop
-      price       : 2392.00
-tax  : 251.42
-total: 4443.52
-comments:
-    Late afternoon is best.
-    Backup contact is Nancy
-    Billsmer @ 338-4338.

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

@@ -1,29 +0,0 @@
----
-Time: 2001-11-23 15:01:42 -5
-User: ed
-Warning:
-  This is an error message
-  for the log file
----
-Time: 2001-11-23 15:02:31 -5
-User: ed
-Warning:
-  A slightly different error
-  message.
----
-Date: 2001-11-23 15:03:17 -5
-User: ed
-Fatal:
-  Unknown variable "bar"
-Stack:
-  - file: TopClass.py
-    line: 23
-    code: |
-      x = MoreObject("345\n")
-  - file: MoreClass.py
-    line: 58
-    code: |-
-      foo = bar
-
-
-

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

@@ -1,8 +0,0 @@
-american:
-  - Boston Red Sox
-  - Detroit Tigers
-  - New York Yankees
-national:
-  - New York Mets
-  - Chicago Cubs
-  - Atlanta Braves

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

@@ -1,8 +0,0 @@
--
-  name: Mark McGwire
-  hr:   65
-  avg:  0.278
--
-  name: Sammy Sosa
-  hr:   63
-  avg:  0.288

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

@@ -1,5 +0,0 @@
-- [name        , hr, avg  ]
-- [Mark McGwire, 65, 0.278]
-- [Sammy Sosa  , 63, 0.288]
-
-

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

@@ -1,5 +0,0 @@
-Mark McGwire: {hr: 65, avg: 0.278}
-Sammy Sosa: {
-    hr: 63,
-    avg: 0.288
-  }

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

@@ -1,10 +0,0 @@
-# Ranking of 1998 home runs
----
-- Mark McGwire
-- Sammy Sosa
-- Ken Griffey
-
-# Team ranking
----
-- Chicago Cubs
-- St Louis Cardinals

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

@@ -1,10 +0,0 @@
----
-time: 20:03:20
-player: Sammy Sosa
-action: strike (miss)
-...
----
-time: 20:03:47
-player: Sammy Sosa
-action: grand slam
-...

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

@@ -1,8 +0,0 @@
----
-hr: # 1998 hr ranking
-  - Mark McGwire
-  - Sammy Sosa
-rbi:
-  # 1998 rbi ranking
-  - Sammy Sosa
-  - Ken Griffey

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

@@ -1 +0,0 @@
-# Comment only.

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

@@ -1,2 +0,0 @@
-commercial-at: @text
-grave-accent: `text

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

@@ -1,3 +0,0 @@
-|
-  Line break (no glyph)
-  Line break (glyphed)

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

@@ -1,6 +0,0 @@
-# Tabs and spaces
-quoted: "Quoted 	"
-block:	|
-  void main() {
-  	printf("Hello, world!\n");
-  }

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

@@ -1,5 +0,0 @@
-"Fun with \\
-\" \a \b \e \f \
-\n \r \t \v \0 \
-\  \_ \N \L \P \
-\x41 \u0041 \U00000041"