WIP - test by Adrien

Add a section into the doc about how to develop rules' plugins.

.gitignore

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

.travis.yml

@@ -8,15 +8,19 @@ python:
   - 3.7
   - 3.8
   - nightly
+env:
+  - REMOVE_LOCALES=false
+  - REMOVE_LOCALES=true
 install:
   - pip install pyyaml coveralls flake8 flake8-import-order doc8
   - if [[ $TRAVIS_PYTHON_VERSION != 2* ]]; then pip install sphinx; fi
   - pip install .
+  - if [[ $REMOVE_LOCALES = "true" ]]; then sudo rm -rf /usr/lib/locale/*; fi
 script:
   - if [[ $TRAVIS_PYTHON_VERSION != nightly ]]; then flake8 .; fi
   - if [[ $TRAVIS_PYTHON_VERSION != 2* ]]; then doc8 $(git ls-files '*.rst'); fi
   - yamllint --strict $(git ls-files '*.yaml' '*.yml')
-  - coverage run --source=yamllint setup.py test
+  - coverage run --source=yamllint -m unittest discover
   - if [[ $TRAVIS_PYTHON_VERSION != 2* ]]; then
       python setup.py build_sphinx;
     fi

CHANGELOG.rst

@@ -1,6 +1,23 @@
 Changelog
 =========
 
+1.25.0 (2020-09-29)
+-------------------
+
+- Run tests on Travis both with and without UTF-8 locales
+- Improve documentationon 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)
 -------------------
 

CONTRIBUTING.rst

@@ -13,7 +13,9 @@ Pull Request Process
 
    .. code:: bash
 
-    python setup.py test
+    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.
 

docs/configuration.rst

@@ -123,8 +123,8 @@ warning level problems, only error level ones.
 YAML files extensions
 ---------------------
 
-To configure what yamllint should consider as YAML files, set ``yaml-files``
-configuration option. The default is:
+To configure what yamllint should consider as YAML files when listing
+directories, set ``yaml-files`` configuration option. The default is:
 
 .. code-block:: yaml
 

docs/development.rst

@@ -2,7 +2,61 @@ Development
 ===========
 
 yamllint provides both a script and a Python module. The latter can be used to
-write your own linting tools:
+write your own linting tools.
+
+Basic example of running the linter from Python:
+
+.. code-block:: python
+
+   import yamllint
+
+   yaml_config = yamllint.config.YamlLintConfig("extends: default")
+   for p in yamllint.linter.run("example.yaml", yaml_config):
+       print(p.desc, p.line, p.rule)
 
 .. automodule:: yamllint.linter
    :members:
+
+Develop rule plugins
+---------------------
+
+yamllint provides a plugin mechanism using setuptools (pkg_resources) to allow
+adding custom rules. So, you can extend yamllint and add rules with your own
+custom yamllint rule plugins if you developed them.
+
+Yamllint rule plugins must satisfy the followings.
+
+#. It must be a Python package installable using pip and distributed under
+   GPLv3+ same as yamllint.
+#. It must contains the entry point configuration in ``setup.cfg`` or something
+   similar packaging configuration files, to make it installed and working as a
+   yamllint plugin like below. (``<plugin_name>`` is that plugin name and
+   ``<plugin_src_dir>`` is a dir where the rule modules exist.)
+   ::
+
+     [options.entry_points]
+     yamllint.plugins.rules =
+          <plugin_name> = <plugin_src_dir>
+
+#. It must contain custom yamllint rule modules:
+
+   - Each rule module must define a couple of global variables, ID and TYPE. ID
+     must not conflicts with other rules' ID.
+   - Each rule module must define a function named 'check' to test input data
+     complies with the rule.
+   - Each rule module may have other global variables.
+
+     - CONF to define its configuration parameters and those types.
+     - DEFAULT to provide default values for each configuration parameters.
+
+#. It must define a global variable RULES_MAP to provide mappings of rule ID
+   and rule modules to yamllint like this.
+   ::
+
+     RULES_MAP = {
+         # rule ID: rule module
+         a_custom_rule.ID: a_custom_rule
+     }
+
+To develop yamllint rules, the default rules themselves in yamllint may become
+good references.

docs/integration.rst

@@ -17,3 +17,37 @@ Here is an example, to add in your .pre-commit-config.yaml
     hooks:
       - id: yamllint
         args: [-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 automatically. You can also
+force the GitHub Actions output with ``yamllint --format github``.
+
+An example workflow using GitHub Actions:
+
+.. code:: yaml
+
+   ---
+   name: yamllint test
+
+   on: push
+
+   jobs:
+     test:
+       runs-on: ubuntu-latest
+       steps:
+         - uses: actions/checkout@v2
+
+         - name: Set up Python
+           uses: actions/setup-python@v2
+           with:
+             python-version: 3.8
+
+         - name: Install yamllint
+           run: pip install yamllint
+
+         - name: Lint YAML files
+           run: yamllint .

setup.cfg

@@ -11,3 +11,61 @@ all-files = 1
 source-dir = docs
 build-dir = docs/_build
 warning-is-error = 1
+
+[metadata]
+keywords =
+  yaml
+  lint
+  linter
+  syntax
+  checker
+
+url = https://github.com/adrienverge/yamllint
+classifiers =
+  Development Status :: 5 - Production/Stable
+  Environment :: Console
+  Intended Audience :: Developers
+  License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+  Programming Language :: Python :: 2
+  Programming Language :: Python :: 2.7
+  Programming Language :: Python :: 3
+  Programming Language :: Python :: 3.4
+  Programming Language :: Python :: 3.5
+  Programming Language :: Python :: 3.6
+  Programming Language :: Python :: 3.7
+  Programming Language :: Python :: 3.8
+  Topic :: Software Development
+  Topic :: Software Development :: Debuggers
+  Topic :: Software Development :: Quality Assurance
+  Topic :: Software Development :: Testing
+
+project_urls =
+  Documentation = https://yamllint.readthedocs.io
+  Download = https://pypi.org/project/yamllint/#files
+  Bug Tracker = https://github.com/adrienverge/yamllint/issues
+  Source Code = https://github.com/adrienverge/yamllint
+
+[options]
+packages = find:
+
+python_requires = >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
+
+include_package_data = True
+install_requires =
+  pathspec >= 0.5.3
+  pyyaml
+  setuptools
+
+test_suite = tests
+
+[options.packages.find]
+exclude =
+  tests
+  tests.*
+
+[options.package_data]
+yamllint = conf/*.yaml
+
+[options.entry_points]
+console_scripts =
+  yamllint = yamllint.cli:run

setup.py

@@ -14,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from setuptools import find_packages, setup
+from setuptools import setup
 
 from yamllint import (__author__, __license__,
                       APP_NAME, APP_VERSION, APP_DESCRIPTION)
@@ -27,31 +27,4 @@ setup(
     description=APP_DESCRIPTION.split('\n')[0],
     long_description=APP_DESCRIPTION,
     license=__license__,
-    keywords=['yaml', 'lint', 'linter', 'syntax', 'checker'],
-    url='https://github.com/adrienverge/yamllint',
-    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*',
-    classifiers=[
-        'Development Status :: 5 - Production/Stable',
-        'Environment :: Console',
-        'Intended Audience :: Developers',
-        'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
-        'Programming Language :: Python :: 2',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.4',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8',
-        'Topic :: Software Development',
-        'Topic :: Software Development :: Debuggers',
-        'Topic :: Software Development :: Quality Assurance',
-        'Topic :: Software Development :: Testing',
-    ],
-
-    packages=find_packages(exclude=['tests', 'tests.*']),
-    entry_points={'console_scripts': ['yamllint=yamllint.cli:run']},
-    package_data={'yamllint': ['conf/*.yaml']},
-    install_requires=['pathspec >=0.5.3', 'pyyaml'],
-    test_suite='tests',
 )

tests/common.py

@@ -57,7 +57,7 @@ def build_temp_workspace(files):
     tempdir = tempfile.mkdtemp(prefix='yamllint-tests-')
 
     for path, content in files.items():
-        path = os.path.join(tempdir, path)
+        path = os.path.join(tempdir, path).encode('utf-8')
         if not os.path.exists(os.path.dirname(path)):
             os.makedirs(os.path.dirname(path))
 

tests/plugins/example/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2020 Satoru SATOH
+#
+# 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/>.
+
+"""yamllint plugin entry point
+"""
+from __future__ import absolute_import
+
+from . import override_comments
+
+
+RULES_MAP = {
+    override_comments.ID: override_comments
+}

tests/plugins/example/override_comments.py

@@ -0,0 +1,63 @@
+#
+# Copyright (C) 2020 Satoru SATOH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""
+Use this rule to override some comments' rules.
+
+.. rubric:: Options
+
+* Use ``forbid`` to control comments. Set to ``true`` to forbid comments
+  completely.
+
+.. rubric:: Examples
+
+#. With ``override-comments: {forbid: true}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    foo: 1
+
+   the following code snippet would **FAIL**:
+   ::
+
+    # baz
+    foo: 1
+
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+rules:
+  override-comments:
+    forbid: False
+
+"""
+from yamllint.linter import LintProblem
+
+
+ID = 'override-comments'
+TYPE = 'comment'
+CONF = {'forbid': bool}
+DEFAULT = {'forbid': False}
+
+
+def check(conf, comment):
+    """Check if comments are found.
+    """
+    if conf['forbid']:
+        yield LintProblem(comment.line_no, comment.column_no,
+                          'forbidden comment')

tests/plugins/yamllint_plugin_example/setup.cfg

@@ -0,0 +1,11 @@
+[metadata]
+name = yamllint_plugin_example
+version = 1.0.0
+
+[options]
+packages = find:
+install_requires = yamllint
+
+[options.entry_points]
+yamllint.plugins.rules =
+    example = yamllint_plugin_example

tests/plugins/yamllint_plugin_example/setup.py

@@ -0,0 +1,2 @@
+import setuptools
+setuptools.setup()

tests/plugins/yamllint_plugin_example/yamllint_plugin_example/__init__.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2020 Satoru SATOH
+#
+# 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/>.
+
+"""yamllint plugin entry point
+"""
+from __future__ import absolute_import
+
+from . import override_comments, random_failure
+
+
+RULES_MAP = {
+    override_comments.ID: override_comments,
+    random_failure.ID: random_failure,
+}

tests/plugins/yamllint_plugin_example/yamllint_plugin_example/override_comments.py

@@ -0,0 +1,63 @@
+#
+# Copyright (C) 2020 Satoru SATOH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""
+Use this rule to override some comments' rules.
+
+.. rubric:: Options
+
+* Use ``forbid`` to control comments. Set to ``true`` to forbid comments
+  completely.
+
+.. rubric:: Examples
+
+#. With ``override-comments: {forbid: true}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    foo: 1
+
+   the following code snippet would **FAIL**:
+   ::
+
+    # baz
+    foo: 1
+
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+rules:
+  override-comments:
+    forbid: False
+
+"""
+from yamllint.linter import LintProblem
+
+
+ID = 'override-comments'
+TYPE = 'comment'
+CONF = {'forbid': bool}
+DEFAULT = {'forbid': False}
+
+
+def check(conf, comment):
+    """Check if comments are found.
+    """
+    if conf['forbid']:
+        yield LintProblem(comment.line_no, comment.column_no,
+                          'forbidden comment')

tests/plugins/yamllint_plugin_example/yamllint_plugin_example/random_failure.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2020 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 random
+
+from yamllint.linter import LintProblem
+
+
+ID = 'random-failure'
+TYPE = 'token'
+
+
+def check(conf, token, prev, next, nextnext, context):
+    if random.random() > 0.9:
+        yield LintProblem(token.start_mark.line + 1,
+                          token.start_mark.column + 1,
+                          'random failure')

tests/rules/test_braces.py

@@ -31,6 +31,36 @@ 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))
+
     def test_min_spaces(self):
         conf = ('braces:\n'
                 '  max-spaces-inside: -1\n'

tests/rules/test_brackets.py

@@ -31,6 +31,35 @@ 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))
+
     def test_min_spaces(self):
         conf = ('brackets:\n'
                 '  max-spaces-inside: -1\n'

tests/rules/test_octal_values.py

@@ -50,6 +50,8 @@ class OctalValuesTestCase(RuleTestCase):
                    '  - 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'
@@ -74,3 +76,5 @@ class OctalValuesTestCase(RuleTestCase):
                    '  - .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

@@ -330,7 +330,8 @@ class QuotedTestCase(RuleTestCase):
                    '- "%wheel ALL=(ALL) NOPASSWD: ALL"\n'
                    '- \'"quoted"\'\n'
                    '- "\'foo\' == \'bar\'"\n'
-                   '- "\'Mac\' in ansible_facts.product_name"\n',
+                   '- "\'Mac\' in ansible_facts.product_name"\n'
+                   '- \'foo # bar\'\n',
                    conf)
         self.check('---\n'
                    'k1: ""\n'

tests/test_cli.py

@@ -56,6 +56,16 @@ class RunContext(object):
         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:
+        return False
+
+
 class CommandLineTestCase(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -86,7 +96,7 @@ class CommandLineTestCase(unittest.TestCase):
             'no-yaml.json': '---\n'
                             'key: value\n',
             # non-ASCII chars
-            'non-ascii/éçäγλνπ¥/utf-8': (
+            u'non-ascii/éçäγλνπ¥/utf-8': (
                 u'---\n'
                 u'- hétérogénéité\n'
                 u'# 19.99 €\n'
@@ -110,6 +120,8 @@ class CommandLineTestCase(unittest.TestCase):
 
         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(
@@ -425,17 +437,12 @@ class CommandLineTestCase(unittest.TestCase):
             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):
-        path = os.path.join(self.wd, 'non-ascii', 'éçäγλνπ¥', 'utf-8')
-
-        # Make sure the default localization conditions on this "system"
-        # support UTF-8 encoding.
-        try:
-            locale.setlocale(locale.LC_ALL, (None, 'UTF-8'))
-        except locale.Error:
-            self.skipTest('no UTF-8 locale available')
+        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, '', ''))
@@ -542,6 +549,38 @@ class CommandLineTestCase(unittest.TestCase):
         self.assertEqual(
             (ctx.returncode, ctx.stdout, ctx.stderr), (1, 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 = (
+            '::error file=%s,line=2,col=4::[trailing-spaces] trailing'
+            ' spaces\n'
+            '::error file=%s,line=3,col=4::[new-line-at-end-of-file] no'
+            ' new line character at the end of file\n'
+            % (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 = (
+            '::error file=%s,line=2,col=4::[trailing-spaces] trailing'
+            ' spaces\n'
+            '::error file=%s,line=3,col=4::[new-line-at-end-of-file] no'
+            ' new line character at the end of file\n'
+            % (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

tests/test_plugins.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2020 Satoru SATOH
+#
+# 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 unittest
+import warnings
+
+try:
+    from unittest import mock
+except ImportError:  # for python 2.7
+    mock = False
+
+from tests.plugins import example
+
+import yamllint.plugins
+
+
+class FakeEntryPoint(object):
+    """Fake object to mimic pkg_resources.EntryPoint.
+    """
+    RULES_MAP = example.RULES_MAP
+
+    def load(self):
+        """Fake method to return self.
+        """
+        return self
+
+
+class BrokenEntryPoint(FakeEntryPoint):
+    """Fake object to mimic load failure of pkg_resources.EntryPoint.
+    """
+    def load(self):
+        raise ImportError("This entry point should fail always!")
+
+
+class PluginFunctionsTestCase(unittest.TestCase):
+
+    def test_validate_rule_module(self):
+        fun = yamllint.plugins.validate_rule_module
+        rule_mod = example.override_comments
+
+        self.assertFalse(fun(object()))
+        self.assertTrue(fun(rule_mod))
+
+    @unittest.skipIf(not mock, "unittest.mock is not available")
+    def test_validate_rule_module_using_mock(self):
+        fun = yamllint.plugins.validate_rule_module
+        rule_mod = example.override_comments
+
+        with mock.patch.object(rule_mod, "ID", False):
+            self.assertFalse(fun(rule_mod))
+
+        with mock.patch.object(rule_mod, "TYPE", False):
+            self.assertFalse(fun(rule_mod))
+
+        with mock.patch.object(rule_mod, "check", True):
+            self.assertFalse(fun(rule_mod))
+
+    def test_load_plugin_rules_itr(self):
+        fun = yamllint.plugins.load_plugin_rules_itr
+
+        self.assertEqual(list(fun([])), [])
+        self.assertEqual(sorted(fun([FakeEntryPoint(),
+                                     FakeEntryPoint()])),
+                         sorted(FakeEntryPoint.RULES_MAP.items()))
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.assertEqual(list(fun([BrokenEntryPoint()])), [])

tests/test_rules.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2020 Satoru SATOH
+#
+# 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 unittest
+
+try:
+    from unittest import mock
+except ImportError:  # for python 2.7
+    mock = False
+
+from tests.plugins import example
+
+import yamllint.rules
+
+
+RULE_NEVER_EXISTS = "rule_never_exists"
+PLUGIN_RULES = example.RULES_MAP
+
+
+class TestCase(unittest.TestCase):
+    """Test cases for yamllint.rules.__init__.*.
+    """
+    def test_get_default_rule(self):
+        self.assertEqual(yamllint.rules.get(yamllint.rules.braces.ID),
+                         yamllint.rules.braces)
+
+    def test_get_rule_does_not_exist(self):
+        with self.assertRaises(ValueError):
+            yamllint.rules.get(RULE_NEVER_EXISTS)
+
+
+@unittest.skipIf(not mock, "unittest.mock is not available")
+class TestCaseUsingMock(unittest.TestCase):
+    """Test cases for yamllint.rules.__init__.* using mock.
+    """
+    def test_get_default_rule_with_plugins(self):
+        with mock.patch.dict(yamllint.rules._EXTERNAL_RULES, PLUGIN_RULES):
+            self.assertEqual(yamllint.rules.get(yamllint.rules.braces.ID),
+                             yamllint.rules.braces)
+
+    def test_get_plugin_rules(self):
+        plugin_rule_id = example.override_comments.ID
+        plugin_rule_mod = example.override_comments
+
+        with mock.patch.dict(yamllint.rules._EXTERNAL_RULES, PLUGIN_RULES):
+            self.assertEqual(yamllint.rules.get(plugin_rule_id),
+                             plugin_rule_mod)
+
+    def test_get_rule_does_not_exist_with_plugins(self):
+        with mock.patch.dict(yamllint.rules._EXTERNAL_RULES, PLUGIN_RULES):
+            with self.assertRaises(ValueError):
+                yamllint.rules.get(RULE_NEVER_EXISTS)

tests/test_yamllint_directives.py

@@ -232,6 +232,34 @@ class YamllintDirectivesTestCase(RuleTestCase):
                    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'

yamllint/__init__.py

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

yamllint/cli.py

@@ -85,6 +85,19 @@ class Format(object):
             line += '  \033[2m(%s)\033[0m' % problem.rule
         return line
 
+    @staticmethod
+    def github(problem, filename):
+        line = '::'
+        line += problem.level
+        line += ' file=' + filename + ','
+        line += 'line=' + format(problem.line) + ','
+        line += 'col=' + format(problem.column)
+        line += '::'
+        if problem.rule:
+            line += '[' + problem.rule + '] '
+        line += problem.desc
+        return line
+
 
 def show_problems(problems, file, args_format, no_warn):
     max_level = 0
@@ -96,6 +109,10 @@ def show_problems(problems, file, args_format, no_warn):
             continue
         if args_format == 'parsable':
             print(Format.parsable(problem, file))
+        elif args_format == 'github' or (args_format == 'auto' and
+                                         'GITHUB_ACTIONS' in os.environ and
+                                         'GITHUB_WORKFLOW' in os.environ):
+            print(Format.github(problem, file))
         elif args_format == 'colored' or \
                 (args_format == 'auto' and supports_color()):
             if first:
@@ -131,7 +148,8 @@ def run(argv=None):
                               action='store',
                               help='custom configuration (as YAML source)')
     parser.add_argument('-f', '--format',
-                        choices=('parsable', 'standard', 'colored', 'auto'),
+                        choices=('parsable', 'standard', 'colored', 'github',
+                                 'auto'),
                         default='auto', help='format for parsing output')
     parser.add_argument('-s', '--strict',
                         action='store_true',

yamllint/conf/default.yaml

@@ -29,5 +29,7 @@ rules:
   octal-values: disable
   quoted-strings: disable
   trailing-spaces: enable
+  random-failure: enable
+  override-comments: {forbid: true}
   truthy:
     level: warning

yamllint/linter.py

@@ -87,7 +87,8 @@ def get_cosmetic_problems(buffer, conf, filepath):
                 return  # this certainly wasn't a yamllint directive comment
 
             if re.match(r'^# yamllint disable( rule:\S+)*\s*$', comment):
-                rules = [item[5:] for item in comment[18:].split(' ')][1:]
+                items = comment[18:].rstrip().split(' ')
+                rules = [item[5:] for item in items][1:]
                 if len(rules) == 0:
                     self.rules = self.all_rules.copy()
                 else:
@@ -96,7 +97,8 @@ def get_cosmetic_problems(buffer, conf, filepath):
                             self.rules.add(id)
 
             elif re.match(r'^# yamllint enable( rule:\S+)*\s*$', comment):
-                rules = [item[5:] for item in comment[17:].split(' ')][1:]
+                items = comment[17:].rstrip().split(' ')
+                rules = [item[5:] for item in items][1:]
                 if len(rules) == 0:
                     self.rules.clear()
                 else:
@@ -114,7 +116,8 @@ def get_cosmetic_problems(buffer, conf, filepath):
                 return  # this certainly wasn't a yamllint directive comment
 
             if re.match(r'^# yamllint disable-line( rule:\S+)*\s*$', comment):
-                rules = [item[5:] for item in comment[23:].split(' ')][1:]
+                items = comment[23:].rstrip().split(' ')
+                rules = [item[5:] for item in items][1:]
                 if len(rules) == 0:
                     self.rules = self.all_rules.copy()
                 else:

yamllint/plugins.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2020 Satoru SATOH
+#
+# 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/>.
+"""
+Plugin module utilizing setuptools (pkg_resources) to allow users to add their
+own custom lint rules.
+"""
+import warnings
+
+import pkg_resources
+
+
+PACKAGE_GROUP = "yamllint.plugins.rules"
+
+
+def validate_rule_module(rule_mod):
+    """Test if given rule module is valid.
+    """
+    return (getattr(rule_mod, "ID", False) and
+            getattr(rule_mod, "TYPE", False)
+            ) and callable(getattr(rule_mod, "check", False))
+
+
+def load_plugin_rules_itr(entry_points=None, group=PACKAGE_GROUP):
+    """Load custom lint rule plugins."""
+    if not entry_points:
+        entry_points = pkg_resources.iter_entry_points(group)
+
+    rule_ids = set()
+    for entry in entry_points:
+        try:
+            rules = entry.load()
+            for rule_id, rule_mod in rules.RULES_MAP.items():
+                if rule_id in rule_ids or not validate_rule_module(rule_mod):
+                    continue
+
+                print(rule_id, rule_mod)###
+                yield (rule_id, rule_mod)
+                rule_ids.add(rule_id)
+
+        # pkg_resources.EntryPoint.resolve may throw ImportError.
+        except (AttributeError, ImportError):
+            warnings.warn("Could not load the plugin: {}".format(entry),
+                          RuntimeWarning)
+
+
+def get_plugin_rules_map():
+    """Get a mappings of plugin rule's IDs and rules."""
+    return dict((rule_id, rule_mod)
+                for rule_id, rule_mod in load_plugin_rules_itr())

yamllint/rules/__init__.py

@@ -14,6 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import yamllint.plugins
 from yamllint.rules import (
     braces,
     brackets,
@@ -62,9 +63,14 @@ _RULES = {
     truthy.ID: truthy,
 }
 
+_EXTERNAL_RULES = yamllint.plugins.get_plugin_rules_map()
 
-def get(id):
-    if id not in _RULES:
-        raise ValueError('no such rule: "%s"' % id)
 
-    return _RULES[id]
+def get(rule_id):
+    if rule_id in _RULES:
+        return _RULES[rule_id]
+
+    if rule_id in _EXTERNAL_RULES:
+        return _EXTERNAL_RULES[rule_id]
+
+    raise ValueError('no such rule: "%s"' % rule_id)

yamllint/rules/braces.py

@@ -15,10 +15,14 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Use this rule to control the number of spaces inside braces (``{`` and ``}``).
+Use this rule to control the use of flow mappings or number of spaces inside
+braces (``{`` and ``}``).
 
 .. rubric:: Options
 
+* ``forbid`` is used to forbid the use of flow mappings which are denoted by
+  surrounding braces (``{`` and ``}``). Use ``true`` to forbid the use of flow
+  mappings completely.
 * ``min-spaces-inside`` defines the minimal number of spaces required inside
   braces.
 * ``max-spaces-inside`` defines the maximal number of spaces allowed inside
@@ -28,8 +32,34 @@ Use this rule to control the number of spaces inside braces (``{`` and ``}``).
 * ``max-spaces-inside-empty`` defines the maximal number of spaces allowed
   inside empty braces.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   braces:
+     forbid: false
+     min-spaces-inside: 0
+     max-spaces-inside: 0
+     min-spaces-inside-empty: -1
+     max-spaces-inside-empty: -1
+
 .. rubric:: Examples
 
+#. With ``braces: {forbid: true}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    object:
+      key1: 4
+      key2: 8
+
+   the following code snippet would **FAIL**:
+   ::
+
+    object: { key1: 4, key2: 8 }
+
 #. With ``braces: {min-spaces-inside: 0, max-spaces-inside: 0}``
 
    the following code snippet would **PASS**:
@@ -92,23 +122,31 @@ Use this rule to control the number of spaces inside braces (``{`` and ``}``).
 
 import yaml
 
+from yamllint.linter import LintProblem
 from yamllint.rules.common import spaces_after, spaces_before
 
 
 ID = 'braces'
 TYPE = 'token'
-CONF = {'min-spaces-inside': int,
+CONF = {'forbid': bool,
+        'min-spaces-inside': int,
         'max-spaces-inside': int,
         'min-spaces-inside-empty': int,
         'max-spaces-inside-empty': int}
-DEFAULT = {'min-spaces-inside': 0,
+DEFAULT = {'forbid': False,
+           'min-spaces-inside': 0,
            'max-spaces-inside': 0,
            'min-spaces-inside-empty': -1,
            'max-spaces-inside-empty': -1}
 
 
 def check(conf, token, prev, next, nextnext, context):
-    if (isinstance(token, yaml.FlowMappingStartToken) and
+    if conf['forbid'] and isinstance(token, yaml.FlowMappingStartToken):
+        yield LintProblem(token.start_mark.line + 1,
+                          token.end_mark.column + 1,
+                          'forbidden flow mapping')
+
+    elif (isinstance(token, yaml.FlowMappingStartToken) and
             isinstance(next, yaml.FlowMappingEndToken)):
         problem = spaces_after(token, prev, next,
                                min=(conf['min-spaces-inside-empty']

yamllint/rules/brackets.py

@@ -15,11 +15,14 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-Use this rule to control the number of spaces inside brackets (``[`` and
-``]``).
+Use this rule to control the use of flow sequences or the number of spaces
+inside brackets (``[`` and ``]``).
 
 .. rubric:: Options
 
+* ``forbid`` is used to forbid the use of flow sequences which are denoted by
+  surrounding brackets (``[`` and ``]``). Use ``true`` to forbid the use of
+  flow sequences completely.
 * ``min-spaces-inside`` defines the minimal number of spaces required inside
   brackets.
 * ``max-spaces-inside`` defines the maximal number of spaces allowed inside
@@ -29,8 +32,35 @@ Use this rule to control the number of spaces inside brackets (``[`` and
 * ``max-spaces-inside-empty`` defines the maximal number of spaces allowed
   inside empty brackets.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   brackets:
+     forbid: false
+     min-spaces-inside: 0
+     max-spaces-inside: 0
+     min-spaces-inside-empty: -1
+     max-spaces-inside-empty: -1
+
 .. rubric:: Examples
 
+#. With ``brackets: {forbid: true}``
+
+   the following code snippet would **PASS**:
+   ::
+
+    object:
+      - 1
+      - 2
+      - abc
+
+   the following code snippet would **FAIL**:
+   ::
+
+    object: [ 1, 2, abc ]
+
 #. With ``brackets: {min-spaces-inside: 0, max-spaces-inside: 0}``
 
    the following code snippet would **PASS**:
@@ -93,23 +123,31 @@ Use this rule to control the number of spaces inside brackets (``[`` and
 
 import yaml
 
+from yamllint.linter import LintProblem
 from yamllint.rules.common import spaces_after, spaces_before
 
 
 ID = 'brackets'
 TYPE = 'token'
-CONF = {'min-spaces-inside': int,
+CONF = {'forbid': bool,
+        'min-spaces-inside': int,
         'max-spaces-inside': int,
         'min-spaces-inside-empty': int,
         'max-spaces-inside-empty': int}
-DEFAULT = {'min-spaces-inside': 0,
+DEFAULT = {'forbid': False,
+           'min-spaces-inside': 0,
            'max-spaces-inside': 0,
            'min-spaces-inside-empty': -1,
            'max-spaces-inside-empty': -1}
 
 
 def check(conf, token, prev, next, nextnext, context):
-    if (isinstance(token, yaml.FlowSequenceStartToken) and
+    if conf['forbid'] and isinstance(token, yaml.FlowSequenceStartToken):
+        yield LintProblem(token.start_mark.line + 1,
+                          token.end_mark.column + 1,
+                          'forbidden flow sequence')
+
+    elif (isinstance(token, yaml.FlowSequenceStartToken) and
             isinstance(next, yaml.FlowSequenceEndToken)):
         problem = spaces_after(token, prev, next,
                                min=(conf['min-spaces-inside-empty']

yamllint/rules/colons.py

@@ -24,6 +24,15 @@ Use this rule to control the number of spaces before and after colons (``:``).
 * ``max-spaces-after`` defines the maximal number of spaces allowed after
   colons (use ``-1`` to disable).
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   colons:
+     max-spaces-before: 0
+     max-spaces-after: 1
+
 .. rubric:: Examples
 
 #. With ``colons: {max-spaces-before: 0, max-spaces-after: 1}``

yamllint/rules/commas.py

@@ -26,6 +26,16 @@ Use this rule to control the number of spaces before and after commas (``,``).
 * ``max-spaces-after`` defines the maximal number of spaces allowed after
   commas (use ``-1`` to disable).
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   commas:
+     max-spaces-before: 0
+     min-spaces-after: 1
+     max-spaces-after: 1
+
 .. rubric:: Examples
 
 #. With ``commas: {max-spaces-before: 0}``
@@ -66,7 +76,7 @@ Use this rule to control the number of spaces before and after commas (``,``).
    ::
 
     strange var:
-      [10, 20,30, {x: 1, y: 2}]
+      [10, 20, 30, {x: 1, y: 2}]
 
    the following code snippet would **FAIL**:
    ::

yamllint/rules/comments.py

@@ -28,6 +28,16 @@ Use this rule to control the position and formatting of comments.
   content. It defines the minimal required number of spaces between a comment
   and its preceding content.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   comments:
+     require-starting-space: true
+     ignore-shebangs: true
+     min-spaces-from-content: 2
+
 .. rubric:: Examples
 
 #. With ``comments: {require-starting-space: true}``

yamllint/rules/document_end.py

@@ -22,6 +22,14 @@ Use this rule to require or forbid the use of document end marker (``...``).
 * Set ``present`` to ``true`` when the document end marker is required, or to
   ``false`` when it is forbidden.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   document-end:
+     present: true
+
 .. rubric:: Examples
 
 #. With ``document-end: {present: true}``

yamllint/rules/document_start.py

@@ -22,6 +22,14 @@ Use this rule to require or forbid the use of document start marker (``---``).
 * Set ``present`` to ``true`` when the document start marker is required, or to
   ``false`` when it is forbidden.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   document-start:
+     present: true
+
 .. rubric:: Examples
 
 #. With ``document-start: {present: true}``

yamllint/rules/empty_lines.py

@@ -25,6 +25,16 @@ Use this rule to set a maximal number of allowed consecutive blank lines.
 * ``max-end`` defines the maximal number of empty lines allowed at the end of
   the file.  This option takes precedence over ``max``.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   empty-lines:
+     max: 2
+     max-start: 0
+     max-end: 0
+
 .. rubric:: Examples
 
 #. With ``empty-lines: {max: 1}``

yamllint/rules/empty_values.py

@@ -23,6 +23,15 @@ Use this rule to prevent nodes with empty content, that implicitly result in
 * Use ``forbid-in-block-mappings`` to prevent empty values in block mappings.
 * Use ``forbid-in-flow-mappings`` to prevent empty values in flow mappings.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   empty-values:
+     forbid-in-block-mappings: true
+     forbid-in-flow-mappings: true
+
 .. rubric:: Examples
 
 #. With ``empty-values: {forbid-in-block-mappings: true}``

yamllint/rules/hyphens.py

@@ -22,6 +22,14 @@ Use this rule to control the number of spaces after hyphens (``-``).
 * ``max-spaces-after`` defines the maximal number of spaces allowed after
   hyphens.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   hyphens:
+     max-spaces-after: 1
+
 .. rubric:: Examples
 
 #. With ``hyphens: {max-spaces-after: 1}``

yamllint/rules/indentation.py

@@ -32,6 +32,16 @@ Use this rule to control the indentation.
 * ``check-multi-line-strings`` defines whether to lint indentation in
   multi-line strings. Set to ``true`` to enable, ``false`` to disable.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   indentation:
+     spaces: consistent
+     indent-sequences: true
+     check-multi-line-strings: false
+
 .. rubric:: Examples
 
 #. With ``indentation: {spaces: 1}``

yamllint/rules/line_length.py

@@ -30,6 +30,16 @@ recommend running yamllint with Python 3.
 * ``allow-non-breakable-inline-mappings`` implies ``allow-non-breakable-words``
   and extends it to also allow non-breakable words in inline mappings.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   line-length:
+     max: 80
+     allow-non-breakable-words: true
+     allow-non-breakable-inline-mappings: false
+
 .. rubric:: Examples
 
 #. With ``line-length: {max: 70}``

yamllint/rules/new_lines.py

@@ -21,6 +21,14 @@ Use this rule to force the type of new line characters.
 
 * Set ``type`` to ``unix`` to use UNIX-typed new line characters (``\\n``), or
   ``dos`` to use DOS-typed new line characters (``\\r\\n``).
+
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   new-lines:
+     type: unix
 """
 
 

yamllint/rules/octal_values.py

@@ -20,6 +20,20 @@ start with ``0`` are interpreted as octal, but this is not always wanted.
 For instance ``010`` is the city code of Beijing, and should not be
 converted to ``8``.
 
+.. rubric:: Options
+
+* Use ``forbid-implicit-octal`` to prevent numbers starting with ``0``.
+* Use ``forbid-explicit-octal`` to prevent numbers starting with ``0o``.
+
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   octal-values:
+     forbid-implicit-octal: true
+     forbid-explicit-octal: true
+
 .. rubric:: Examples
 
 #. With ``octal-values: {forbid-implicit-octal: true}``
@@ -57,6 +71,8 @@ converted to ``8``.
       city-code: 0o10
 """
 
+import re
+
 import yaml
 
 from yamllint.linter import LintProblem
@@ -70,6 +86,10 @@ DEFAULT = {'forbid-implicit-octal': True,
            'forbid-explicit-octal': True}
 
 
+def _is_octal_number(string):
+    return re.match(r'^[0-7]+$', string) is not None
+
+
 def check(conf, token, prev, next, nextnext, context):
     if prev and isinstance(prev, yaml.tokens.TagToken):
         return
@@ -78,7 +98,8 @@ def check(conf, token, prev, next, nextnext, context):
         if isinstance(token, yaml.tokens.ScalarToken):
             if not token.style:
                 val = token.value
-                if val.isdigit() and len(val) > 1 and val[0] == '0':
+                if (val.isdigit() and len(val) > 1 and val[0] == '0' and
+                        _is_octal_number(val[1:])):
                     yield LintProblem(
                         token.start_mark.line + 1, token.end_mark.column + 1,
                         'forbidden implicit octal value "%s"' %
@@ -88,7 +109,8 @@ def check(conf, token, prev, next, nextnext, context):
         if isinstance(token, yaml.tokens.ScalarToken):
             if not token.style:
                 val = token.value
-                if len(val) > 2 and val[:2] == '0o' and val[2:].isdigit():
+                if (len(val) > 2 and val[:2] == '0o' and
+                        _is_octal_number(val[2:])):
                     yield LintProblem(
                         token.start_mark.line + 1, token.end_mark.column + 1,
                         'forbidden explicit octal value "%s"' %

yamllint/rules/quoted_strings.py

@@ -34,6 +34,17 @@ used.
 
 **Note**: Multi-line strings (with ``|`` or ``>``) will not be checked.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   quoted-strings:
+     quote-type: any
+     required: true
+     extra-required: []
+     extra-allowed: []
+
 .. rubric:: Examples
 
 #. With ``quoted-strings: {quote-type: any, required: true}``
@@ -149,7 +160,7 @@ def _quotes_are_needed(string):
     try:
         a, b = loader.get_token(), loader.get_token()
         if (isinstance(a, yaml.ScalarToken) and a.style is None and
-                isinstance(b, yaml.BlockEndToken)):
+                isinstance(b, yaml.BlockEndToken) and a.value == string):
             return False
         return True
     except yaml.scanner.ScannerError:

yamllint/rules/truthy.py

@@ -34,6 +34,15 @@ This can be useful to prevent surprises from YAML parsers transforming
   ``truthy`` rule applies to both keys and values. Set this option to ``false``
   to prevent this.
 
+.. rubric:: Default values (when enabled)
+
+.. code-block:: yaml
+
+ rules:
+   truthy:
+     allowed-values: ['true', 'false']
+     check-keys: true
+
 .. rubric:: Examples
 
 #. With ``truthy: {}``