yamllint version 0.5.2

With the new project layout, `pyyaml` is not needed anymore for parsing
setup.py.

.travis.yml

@@ -1,7 +1,6 @@
 ---
 language: python
 python:
-  - 2.6
   - 2.7
   - 3.3
   - 3.4

README.rst

@@ -36,7 +36,7 @@ Installation
 
 .. code:: bash
 
- pip install yamllint
+ sudo pip install yamllint
 
 Usage
 ^^^^^

bin/yamllint

@@ -1,24 +0,0 @@
-#!/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/>.
-
-import sys
-
-from yamllint import cli
-
-
-if __name__ == '__main__':
-    cli.run(sys.argv[1:])

docs/development.rst

@@ -4,8 +4,5 @@ Development
 yamllint provides both a script and a Python module. The latter can be used to
 write your own linting tools:
 
-.. autoclass:: yamllint.errors.LintProblem
-   :members:
-
-.. automodule:: yamllint
+.. automodule:: yamllint.linter
    :members:

setup.py

@@ -42,11 +42,9 @@ setup(
     ],
 
     packages=find_packages(),
-    scripts=['bin/yamllint'],
+    entry_points={'console_scripts': ['yamllint=yamllint.cli:run']},
     package_data={'yamllint': ['conf/*.yml']},
     install_requires=['pyyaml'],
-    setup_requires=['pyyaml'],  # importing `yamllint` (for APP_NAME etc.)
-                                # requires importing `yaml`
     tests_require=['nose'],
     test_suite='nose.collector',
 )

tests/rules/common.py

@@ -18,9 +18,8 @@ import unittest
 
 import yaml
 
-from yamllint.config import parse_config
-from yamllint.errors import LintProblem
-from yamllint import lint
+from yamllint.config import YamlLintConfig
+from yamllint import linter
 
 
 class RuleTestCase(unittest.TestCase):
@@ -31,7 +30,7 @@ class RuleTestCase(unittest.TestCase):
             conf = yaml.safe_load(conf)
         conf = {'extends': 'default',
                 'rules': conf}
-        return parse_config(yaml.safe_dump(conf))
+        return YamlLintConfig(yaml.safe_dump(conf))
 
     def check(self, source, conf, **kwargs):
         expected_problems = []
@@ -44,9 +43,9 @@ class RuleTestCase(unittest.TestCase):
                     rule_id = kwargs[key][2]
             else:
                 rule_id = self.rule_id
-            expected_problems.append(
-                LintProblem(kwargs[key][0], kwargs[key][1], rule=rule_id))
+            expected_problems.append(linter.LintProblem(
+                kwargs[key][0], kwargs[key][1], rule=rule_id))
         expected_problems.sort()
 
-        real_problems = list(lint(source, self.build_fake_config(conf)))
+        real_problems = list(linter.run(source, self.build_fake_config(conf)))
         self.assertEqual(real_problems, expected_problems)

tests/test_config.py

@@ -14,56 +14,164 @@
 # 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 unittest
 
 from yamllint import config
 
 
-class ConfigTestCase(unittest.TestCase):
-    def setUp(self):
-        self.base = config.parse_config_from_file(os.path.join(
-            os.path.dirname(os.path.dirname(os.path.realpath(__file__))),
-            'yamllint', 'conf', 'default.yml'))
+class SimpleConfigTestCase(unittest.TestCase):
+    def test_parse_config(self):
+        new = config.YamlLintConfig('rules:\n'
+                                    '  colons:\n'
+                                    '    max-spaces-before: 0\n'
+                                    '    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()), 1)
+
+    def test_unknown_rule(self):
+        with self.assertRaisesRegexp(
+                config.YamlLintConfigError,
+                'invalid config: no such rule: "this-one-does-not-exist"'):
+            config.YamlLintConfig('rules:\n'
+                                  '  this-one-does-not-exist: {}\n')
+
+    def test_missing_option(self):
+        with self.assertRaisesRegexp(
+                config.YamlLintConfigError,
+                'invalid config: missing option "max-spaces-before" '
+                'for rule "colons"'):
+            config.YamlLintConfig('rules:\n'
+                                  '  colons:\n'
+                                  '    max-spaces-after: 1\n')
+
+    def test_unknown_option(self):
+        with self.assertRaisesRegexp(
+                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')
+
+
+class ExtendedConfigTestCase(unittest.TestCase):
+    def test_extend_add_rule(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()), 2)
+
+    def test_extend_remove_rule(self):
+        old = config.YamlLintConfig('rules:\n'
+                                    '  colons:\n'
+                                    '    max-spaces-before: 0\n'
+                                    '    max-spaces-after: 1\n'
+                                    '  hyphens:\n'
+                                    '    max-spaces-after: 2\n')
+        new = config.YamlLintConfig('rules:\n'
+                                    '  colons: disable\n')
+        new.extend(old)
+
+        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(new.rules['colons'], False)
+        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
+
+        self.assertEqual(len(new.enabled_rules()), 1)
+
+    def test_extend_edit_rule(self):
+        old = config.YamlLintConfig('rules:\n'
+                                    '  colons:\n'
+                                    '    max-spaces-before: 0\n'
+                                    '    max-spaces-after: 1\n'
+                                    '  hyphens:\n'
+                                    '    max-spaces-after: 2\n')
+        new = config.YamlLintConfig('rules:\n'
+                                    '  colons:\n'
+                                    '    max-spaces-before: 3\n'
+                                    '    max-spaces-after: 4\n')
+        new.extend(old)
+
+        self.assertEqual(sorted(new.rules.keys()), ['colons', 'hyphens'])
+        self.assertEqual(new.rules['colons']['max-spaces-before'], 3)
+        self.assertEqual(new.rules['colons']['max-spaces-after'], 4)
+        self.assertEqual(new.rules['hyphens']['max-spaces-after'], 2)
+
+        self.assertEqual(len(new.enabled_rules()), 2)
+
+    def test_extend_reenable_rule(self):
+        old = config.YamlLintConfig('rules:\n'
+                                    '  colons:\n'
+                                    '    max-spaces-before: 0\n'
+                                    '    max-spaces-after: 1\n'
+                                    '  hyphens: disable\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()), 2)
+
+
+class ExtendedLibraryConfigTestCase(unittest.TestCase):
     def test_extend_config_disable_rule(self):
-        new = config.parse_config('extends: default\n'
-                                  'rules:\n'
-                                  '  trailing-spaces: disable\n')
+        old = config.YamlLintConfig('extends: default')
+        new = config.YamlLintConfig('extends: default\n'
+                                    'rules:\n'
+                                    '  trailing-spaces: disable\n')
 
-        base = self.base.copy()
-        del base['trailing-spaces']
+        old.rules['trailing-spaces'] = False
 
-        self.assertEqual(sorted(new.keys()), sorted(base.keys()))
-        for rule in new:
-            self.assertEqual(new[rule], base[rule])
+        self.assertEqual(sorted(new.rules.keys()), sorted(old.rules.keys()))
+        for rule in new.rules:
+            self.assertEqual(new.rules[rule], old.rules[rule])
 
     def test_extend_config_override_whole_rule(self):
-        new = config.parse_config('extends: default\n'
-                                  'rules:\n'
-                                  '  empty-lines:\n'
-                                  '    max: 42\n'
-                                  '    max-start: 43\n'
-                                  '    max-end: 44\n')
+        old = config.YamlLintConfig('extends: default')
+        new = config.YamlLintConfig('extends: default\n'
+                                    'rules:\n'
+                                    '  empty-lines:\n'
+                                    '    max: 42\n'
+                                    '    max-start: 43\n'
+                                    '    max-end: 44\n')
 
-        base = self.base.copy()
-        base['empty-lines']['max'] = 42
-        base['empty-lines']['max-start'] = 43
-        base['empty-lines']['max-end'] = 44
+        old.rules['empty-lines']['max'] = 42
+        old.rules['empty-lines']['max-start'] = 43
+        old.rules['empty-lines']['max-end'] = 44
 
-        self.assertEqual(sorted(new.keys()), sorted(base.keys()))
-        for rule in new:
-            self.assertEqual(new[rule], base[rule])
+        self.assertEqual(sorted(new.rules.keys()), sorted(old.rules.keys()))
+        for rule in new.rules:
+            self.assertEqual(new.rules[rule], old.rules[rule])
 
     def test_extend_config_override_rule_partly(self):
-        new = config.parse_config('extends: default\n'
-                                  'rules:\n'
-                                  '  empty-lines:\n'
-                                  '    max-start: 42\n')
+        old = config.YamlLintConfig('extends: default')
+        new = config.YamlLintConfig('extends: default\n'
+                                    'rules:\n'
+                                    '  empty-lines:\n'
+                                    '    max-start: 42\n')
 
-        base = self.base.copy()
-        base['empty-lines']['max-start'] = 42
+        old.rules['empty-lines']['max-start'] = 42
 
-        self.assertEqual(sorted(new.keys()), sorted(base.keys()))
-        for rule in new:
-            self.assertEqual(new[rule], base[rule])
+        self.assertEqual(sorted(new.rules.keys()), sorted(old.rules.keys()))
+        for rule in new.rules:
+            self.assertEqual(new.rules[rule], old.rules[rule])

tests/test_parser.py

@@ -65,8 +65,8 @@ class ParserTestCase(unittest.TestCase):
         e = list(token_generator(''))
         self.assertEqual(len(e), 2)
         self.assertEqual(e[0].prev, None)
-        self.assertTrue(isinstance(e[0].curr, yaml.Token))
-        self.assertTrue(isinstance(e[0].next, yaml.Token))
+        self.assertIsInstance(e[0].curr, yaml.Token)
+        self.assertIsInstance(e[0].next, yaml.Token)
         self.assertEqual(e[1].prev, e[0].curr)
         self.assertEqual(e[1].curr, e[0].next)
         self.assertEqual(e[1].next, None)
@@ -74,20 +74,20 @@ class ParserTestCase(unittest.TestCase):
         e = list(token_generator('---\n'
                                  'k: v\n'))
         self.assertEqual(len(e), 9)
-        self.assertTrue(isinstance(e[3].curr, yaml.KeyToken))
-        self.assertTrue(isinstance(e[5].curr, yaml.ValueToken))
+        self.assertIsInstance(e[3].curr, yaml.KeyToken)
+        self.assertIsInstance(e[5].curr, yaml.ValueToken)
 
     def test_token_or_line_generator(self):
         e = list(token_or_line_generator('---\n'
                                          'k: v\n'))
         self.assertEqual(len(e), 12)
-        self.assertTrue(isinstance(e[0], Token))
-        self.assertTrue(isinstance(e[0].curr, yaml.StreamStartToken))
-        self.assertTrue(isinstance(e[1], Token))
-        self.assertTrue(isinstance(e[1].curr, yaml.DocumentStartToken))
-        self.assertTrue(isinstance(e[2], Line))
-        self.assertTrue(isinstance(e[3].curr, yaml.BlockMappingStartToken))
-        self.assertTrue(isinstance(e[4].curr, yaml.KeyToken))
-        self.assertTrue(isinstance(e[6].curr, yaml.ValueToken))
-        self.assertTrue(isinstance(e[8], Line))
-        self.assertTrue(isinstance(e[11], Line))
+        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], Line)
+        self.assertIsInstance(e[11], Line)

yamllint/__init__.py

@@ -14,104 +14,11 @@
 # 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 yaml
-
-from yamllint import config
-from yamllint.errors import LintProblem
-from yamllint import parser
-
-
 APP_NAME = 'yamllint'
-APP_VERSION = '0.5.1'
+APP_VERSION = '0.5.2'
 APP_DESCRIPTION = 'A linter for YAML files.'
 
 __author__ = u'Adrien Vergé'
 __copyright__ = u'Copyright 2016, Adrien Vergé'
 __license__ = 'GPLv3'
 __version__ = APP_VERSION
-
-
-def get_costemic_problems(buffer, conf):
-    rules = config.get_enabled_rules(conf)
-
-    # Split token rules from line rules
-    token_rules = [r for r in rules if r.TYPE == 'token']
-    line_rules = [r for r in rules if r.TYPE == 'line']
-
-    context = {}
-    for rule in token_rules:
-        context[rule.ID] = {}
-
-    for elem in parser.token_or_line_generator(buffer):
-        if isinstance(elem, parser.Token):
-            for rule in token_rules:
-                rule_conf = conf[rule.ID]
-                for problem in rule.check(rule_conf,
-                                          elem.curr, elem.prev, elem.next,
-                                          context[rule.ID]):
-                    problem.rule = rule.ID
-                    problem.level = rule_conf['level']
-                    yield problem
-        elif isinstance(elem, parser.Line):
-            for rule in line_rules:
-                rule_conf = conf[rule.ID]
-                for problem in rule.check(rule_conf, elem):
-                    problem.rule = rule.ID
-                    problem.level = rule_conf['level']
-                    yield problem
-
-
-def get_syntax_error(buffer):
-    try:
-        list(yaml.parse(buffer, Loader=yaml.BaseLoader))
-    except yaml.error.MarkedYAMLError as e:
-        problem = LintProblem(e.problem_mark.line + 1,
-                              e.problem_mark.column + 1,
-                              'syntax error: ' + e.problem)
-        problem.level = 'error'
-        return problem
-
-
-def _lint(buffer, conf):
-    # If the document contains a syntax error, save it and yield it at the
-    # right line
-    syntax_error = get_syntax_error(buffer)
-
-    for problem in get_costemic_problems(buffer, conf):
-        # Insert the syntax error (if any) at the right place...
-        if (syntax_error and syntax_error.line <= problem.line and
-                syntax_error.column <= problem.column):
-            yield syntax_error
-
-            # If there is already a yamllint error at the same place, discard
-            # it as it is probably redundant (and maybe it's just a 'warning',
-            # in which case the script won't even exit with a failure status).
-            if (syntax_error.line == problem.line and
-                    syntax_error.column == problem.column):
-                syntax_error = None
-                continue
-
-            syntax_error = None
-
-        yield problem
-
-    if syntax_error:
-        yield syntax_error
-
-
-def lint(input, conf):
-    """Lints a YAML source.
-
-    Returns a generator of LintProblem objects.
-
-    :param input: buffer, string or stream to read from
-    :param conf: yamllint configuration object
-    """
-    if type(input) == str:
-        return _lint(input, conf)
-    elif hasattr(input, 'read'):  # Python 2's file or Python 3's io.IOBase
-        # We need to have everything in memory to parse correctly
-        content = input.read()
-        return _lint(content, conf)
-    else:
-        raise TypeError('input should be a string or a stream')

yamllint/cli.py

@@ -22,9 +22,8 @@ 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.config import YamlLintConfig, YamlLintConfigError
+from yamllint import linter
 
 
 def find_files_recursively(items):
@@ -63,7 +62,7 @@ class Format(object):
         return line
 
 
-def run(argv):
+def run(argv=None):
     parser = argparse.ArgumentParser(prog=APP_NAME,
                                      description=APP_DESCRIPTION)
     parser.add_argument('files', metavar='FILE_OR_DIR', nargs='+',
@@ -82,11 +81,11 @@ def run(argv):
 
     try:
         if args.config_file is not None:
-            conf = config.parse_config_from_file(args.config_file)
+            conf = YamlLintConfig(file=args.config_file)
         elif os.path.isfile('.yamllint'):
-            conf = config.parse_config_from_file('.yamllint')
+            conf = YamlLintConfig(file='.yamllint')
         else:
-            conf = config.parse_config('extends: default')
+            conf = YamlLintConfig('extends: default')
     except YamlLintConfigError as e:
         print(e, file=sys.stderr)
         sys.exit(-1)
@@ -97,7 +96,7 @@ def run(argv):
         try:
             first = True
             with open(file) as f:
-                for problem in lint(f, conf):
+                for problem in linter.run(f, conf):
                     if args.format == 'parsable':
                         print(Format.parsable(problem, file))
                     else:

yamllint/config.py

@@ -19,10 +19,109 @@ import os.path
 import yaml
 
 import yamllint.rules
-from yamllint.errors import YamlLintConfigError
 
 
-def get_extended_conf(name):
+class YamlLintConfigError(Exception):
+    pass
+
+
+class YamlLintConfig(object):
+    def __init__(self, content=None, file=None):
+        assert (content is None) ^ (file is None)
+
+        if file is not None:
+            with open(file) as f:
+                content = f.read()
+
+        self.parse(content)
+        self.validate()
+
+    def enabled_rules(self):
+        return [yamllint.rules.get(id) for id, val in self.rules.items()
+                if val is not False]
+
+    def extend(self, base_config):
+        assert isinstance(base_config, YamlLintConfig)
+
+        for rule in self.rules:
+            if (type(self.rules[rule]) == dict and
+                    rule in base_config.rules and
+                    base_config.rules[rule] is not False):
+                base_config.rules[rule].update(self.rules[rule])
+            else:
+                base_config.rules[rule] = self.rules[rule]
+
+        self.rules = base_config.rules
+
+    def parse(self, raw_content):
+        try:
+            conf = yaml.safe_load(raw_content)
+        except Exception as e:
+            raise YamlLintConfigError('invalid config: %s' % e)
+
+        self.rules = conf.get('rules', {})
+
+        # Does this conf override another conf that we need to load?
+        if 'extends' in conf:
+            path = get_extended_config_file(conf['extends'])
+            base = YamlLintConfig(file=path)
+            try:
+                self.extend(base)
+            except Exception as e:
+                raise YamlLintConfigError('invalid config: %s' % e)
+
+    def validate(self):
+        for id in self.rules:
+            try:
+                rule = yamllint.rules.get(id)
+            except Exception as e:
+                raise YamlLintConfigError('invalid config: %s' % e)
+
+            self.rules[id] = validate_rule_conf(rule, self.rules[id])
+
+
+def validate_rule_conf(rule, conf):
+    if conf is False or conf == 'disable':
+        return False
+
+    if type(conf) == dict:
+        if 'level' not in conf:
+            conf['level'] = 'error'
+        elif conf['level'] not in ('error', 'warning'):
+            raise YamlLintConfigError(
+                'invalid config: level should be "error" or "warning"')
+
+        options = getattr(rule, 'CONF', {})
+        for optkey in conf:
+            if optkey == 'level':
+                continue
+            if optkey not in options:
+                raise YamlLintConfigError(
+                    'invalid config: unknown option "%s" for rule "%s"' %
+                    (optkey, rule.ID))
+            if type(options[optkey]) == tuple:
+                if conf[optkey] not in options[optkey]:
+                    raise YamlLintConfigError(
+                        'invalid config: option "%s" of "%s" should be in %s'
+                        % (optkey, rule.ID, options[optkey]))
+            else:
+                if type(conf[optkey]) != options[optkey]:
+                    raise YamlLintConfigError(
+                        'invalid config: option "%s" of "%s" should be %s'
+                        % (optkey, rule.ID, options[optkey].__name__))
+        for optkey in options:
+            if optkey not in conf:
+                raise YamlLintConfigError(
+                    'invalid config: missing option "%s" for rule "%s"' %
+                    (optkey, rule.ID))
+    else:
+        raise YamlLintConfigError(('invalid config: rule "%s": should be '
+                                   'either "disable" or a dict') % rule.ID)
+
+    return conf
+
+
+def get_extended_config_file(name):
     # Is it a standard conf shipped with yamllint...
     if '/' not in name:
         std_conf = os.path.join(os.path.dirname(os.path.realpath(__file__)),
@@ -33,81 +132,3 @@ def get_extended_conf(name):
 
     # or a custom conf on filesystem?
     return name
-
-
-def extend_config(content):
-    try:
-        conf = yaml.safe_load(content)
-
-        if 'rules' not in conf:
-            conf['rules'] = {}
-
-        # Does this conf override another conf that we need to load?
-        if 'extends' in conf:
-            base = parse_config_from_file(get_extended_conf(conf['extends']))
-
-            for rule in conf['rules']:
-                if type(conf['rules'][rule]) == dict and rule in base:
-                    base[rule].update(conf['rules'][rule])
-                else:
-                    base[rule] = conf['rules'][rule]
-            conf['rules'] = base
-
-        return conf
-    except Exception as e:
-        raise YamlLintConfigError('invalid config: %s' % e)
-
-
-def parse_config(content):
-    conf = extend_config(content)
-    rules = {}
-
-    for id in conf['rules']:
-        try:
-            rule = yamllint.rules.get(id)
-        except Exception as e:
-            raise YamlLintConfigError('invalid config: %s' % e)
-
-        if conf['rules'][id] == 'disable':
-            continue
-
-        rules[id] = {'level': 'error'}
-        if type(conf['rules'][id]) == dict:
-            if 'level' in conf['rules'][id]:
-                if conf['rules'][id]['level'] not in ('error', 'warning'):
-                    raise YamlLintConfigError(
-                        'invalid config: level should be "error" or "warning"')
-                rules[id]['level'] = conf['rules'][id]['level']
-
-            options = getattr(rule, 'CONF', {})
-            for optkey in conf['rules'][id]:
-                if optkey == 'level':
-                    continue
-                if optkey not in options:
-                    raise YamlLintConfigError(
-                        'invalid config: unknown option "%s" for rule "%s"' %
-                        (optkey, id))
-                if type(options[optkey]) == tuple:
-                    if conf['rules'][id][optkey] not in options[optkey]:
-                        raise YamlLintConfigError(
-                            ('invalid config: option "%s" of "%s" should be '
-                             'in %s') % (optkey, id, options[optkey]))
-                else:
-                    if type(conf['rules'][id][optkey]) != options[optkey]:
-                        raise YamlLintConfigError(
-                            ('invalid config: option "%s" of "%s" should be '
-                             '%s' % (optkey, id, options[optkey].__name__)))
-                rules[id][optkey] = conf['rules'][id][optkey]
-        else:
-            raise YamlLintConfigError(('invalid config: rule "%s": should be '
-                                       'either "disable" or a dict') % id)
-    return rules
-
-
-def parse_config_from_file(path):
-    with open(path) as f:
-        return parse_config(f.read())
-
-
-def get_enabled_rules(conf):
-    return [yamllint.rules.get(r) for r in conf.keys() if conf[r] is not False]

yamllint/errors.py

@@ -1,55 +0,0 @@
-# -*- 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/>.
-
-
-class LintProblem(object):
-    """Represents a linting problem found by yamllint."""
-    def __init__(self, line, column, desc='<no description>', rule=None):
-        #: Line on which the problem was found (starting at 1)
-        self.line = line
-        #: Column on which the problem was found (starting at 1)
-        self.column = column
-        #: Human-readable description of the problem
-        self.desc = desc
-        #: Identifier of the rule that detected the problem
-        self.rule = rule
-        self.level = None
-
-    @property
-    def message(self):
-        if self.rule is not None:
-            return '%s (%s)' % (self.desc, self.rule)
-        return self.desc
-
-    def __eq__(self, other):
-        return (self.line == other.line and
-                self.column == other.column and
-                self.rule == other.rule)
-
-    def __lt__(self, other):
-        return (self.line < other.line or
-                (self.line == other.line and self.column < other.column))
-
-    def __repr__(self):
-        return '%d:%d: %s' % (self.line, self.column, self.message)
-
-
-class YamlLintError(Exception):
-    pass
-
-
-class YamlLintConfigError(YamlLintError):
-    pass

yamllint/linter.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2016 Adrien Vergé
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import yaml
+
+from yamllint import parser
+
+
+class LintProblem(object):
+    """Represents a linting problem found by yamllint."""
+    def __init__(self, line, column, desc='<no description>', rule=None):
+        #: Line on which the problem was found (starting at 1)
+        self.line = line
+        #: Column on which the problem was found (starting at 1)
+        self.column = column
+        #: Human-readable description of the problem
+        self.desc = desc
+        #: Identifier of the rule that detected the problem
+        self.rule = rule
+        self.level = None
+
+    @property
+    def message(self):
+        if self.rule is not None:
+            return '%s (%s)' % (self.desc, self.rule)
+        return self.desc
+
+    def __eq__(self, other):
+        return (self.line == other.line and
+                self.column == other.column and
+                self.rule == other.rule)
+
+    def __lt__(self, other):
+        return (self.line < other.line or
+                (self.line == other.line and self.column < other.column))
+
+    def __repr__(self):
+        return '%d:%d: %s' % (self.line, self.column, self.message)
+
+
+def get_costemic_problems(buffer, conf):
+    rules = conf.enabled_rules()
+
+    # Split token rules from line rules
+    token_rules = [r for r in rules if r.TYPE == 'token']
+    line_rules = [r for r in rules if r.TYPE == 'line']
+
+    context = {}
+    for rule in token_rules:
+        context[rule.ID] = {}
+
+    for elem in parser.token_or_line_generator(buffer):
+        if isinstance(elem, parser.Token):
+            for rule in token_rules:
+                rule_conf = conf.rules[rule.ID]
+                for problem in rule.check(rule_conf,
+                                          elem.curr, elem.prev, elem.next,
+                                          context[rule.ID]):
+                    problem.rule = rule.ID
+                    problem.level = rule_conf['level']
+                    yield problem
+        elif isinstance(elem, parser.Line):
+            for rule in line_rules:
+                rule_conf = conf.rules[rule.ID]
+                for problem in rule.check(rule_conf, elem):
+                    problem.rule = rule.ID
+                    problem.level = rule_conf['level']
+                    yield problem
+
+
+def get_syntax_error(buffer):
+    try:
+        list(yaml.parse(buffer, Loader=yaml.BaseLoader))
+    except yaml.error.MarkedYAMLError as e:
+        problem = LintProblem(e.problem_mark.line + 1,
+                              e.problem_mark.column + 1,
+                              'syntax error: ' + e.problem)
+        problem.level = 'error'
+        return problem
+
+
+def _run(buffer, conf):
+    # If the document contains a syntax error, save it and yield it at the
+    # right line
+    syntax_error = get_syntax_error(buffer)
+
+    for problem in get_costemic_problems(buffer, conf):
+        # Insert the syntax error (if any) at the right place...
+        if (syntax_error and syntax_error.line <= problem.line and
+                syntax_error.column <= problem.column):
+            yield syntax_error
+
+            # If there is already a yamllint error at the same place, discard
+            # it as it is probably redundant (and maybe it's just a 'warning',
+            # in which case the script won't even exit with a failure status).
+            if (syntax_error.line == problem.line and
+                    syntax_error.column == problem.column):
+                syntax_error = None
+                continue
+
+            syntax_error = None
+
+        yield problem
+
+    if syntax_error:
+        yield syntax_error
+
+
+def run(input, conf):
+    """Lints a YAML source.
+
+    Returns a generator of LintProblem objects.
+
+    :param input: buffer, string or stream to read from
+    :param conf: yamllint configuration object
+    """
+    if type(input) == str:
+        return _run(input, conf)
+    elif hasattr(input, 'read'):  # Python 2's file or Python 3's io.IOBase
+        # We need to have everything in memory to parse correctly
+        content = input.read()
+        return _run(content, conf)
+    else:
+        raise TypeError('input should be a string or a stream')

yamllint/rules/commas.py

@@ -64,7 +64,7 @@ Use this rule to control the number of spaces before and after commas (``,``).
 
 import yaml
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 from yamllint.rules.common import spaces_after, spaces_before
 
 

yamllint/rules/comments.py

@@ -57,7 +57,7 @@ Use this rule to control the position and formatting of comments.
 
 import yaml
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 from yamllint.rules.common import get_comments_between_tokens
 
 

yamllint/rules/comments_indentation.py

@@ -77,7 +77,7 @@ Use this rule to force comments to be indented like content.
 
 import yaml
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 from yamllint.rules.common import get_line_indent, get_comments_between_tokens
 
 

yamllint/rules/common.py

@@ -16,7 +16,7 @@
 
 import yaml
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 
 
 def spaces_after(token, prev, next, min=-1, max=-1,

yamllint/rules/document_end.py

@@ -76,7 +76,7 @@ Use this rule to require or forbid the use of document end marker (``...``).
 
 import yaml
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 
 
 ID = 'document-end'

yamllint/rules/document_start.py

@@ -66,7 +66,7 @@ Use this rule to require or forbid the use of document start marker (``---``).
 
 import yaml
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 
 
 ID = 'document-start'

yamllint/rules/empty_lines.py

@@ -50,7 +50,7 @@ Use this rule to set a maximal number of allowed consecutive blank lines.
 """
 
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 
 
 ID = 'empty-lines'

yamllint/rules/indentation.py

@@ -132,7 +132,7 @@ Use this rule to control the indentation.
 
 import yaml
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 from yamllint.rules.common import is_explicit_key
 
 

yamllint/rules/line_length.py

@@ -41,7 +41,7 @@ Use this rule to set a limit to lines length.
 """
 
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 
 
 ID = 'line-length'

yamllint/rules/new_line_at_end_of_file.py

@@ -24,7 +24,7 @@ this convention too.
 """
 
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 
 
 ID = 'new-line-at-end-of-file'

yamllint/rules/new_lines.py

@@ -24,7 +24,7 @@ Use this rule to force the type of new line characters.
 """
 
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 
 
 ID = 'new-lines'

yamllint/rules/trailing_spaces.py

@@ -39,7 +39,7 @@ Use this rule to forbid trailing spaces at the end of lines.
 
 import string
 
-from yamllint.errors import LintProblem
+from yamllint.linter import LintProblem
 
 
 ID = 'trailing-spaces'