Implement AutocmdParser

test/asserting/policy.py

@@ -65,7 +65,7 @@ def assertFoundViolationsEqual(self, path, Policy, expected_violations, policy_o
         violations = linter.lint_file(path)
 
         pprint(violations)
-        assert len(violations) == len(expected_violations)
+        self.assertEqual(len(violations), len(expected_violations))
 
         for violation, expected_violation in zip_longest(violations, expected_violations):
             self.assertViolation(violation, expected_violation)
@@ -77,9 +77,9 @@ def assertViolation(self, actual_violation, expected_violation):
 
         pprint(actual_violation)
 
-        assert actual_violation['name'] == expected_violation['name']
-        assert actual_violation['position'] == expected_violation['position']
-        assert actual_violation['level'] == expected_violation['level']
+        self.assertEqual(actual_violation['name'], expected_violation['name'], 'name')
+        self.assertEqual(actual_violation['position'], expected_violation['position'], 'position')
+        self.assertEqual(actual_violation['level'], expected_violation['level'], 'level')
 
         self.assertIsInstance(actual_violation['description'], str)
 

test/fixture/ast/fixture_traversing_find_all.vim

@@ -0,0 +1,6 @@
+echo 0
+echoerr 0
+echo 1
+echoerr 1
+echo 2
+echoerr 2

test/unit/vint/ast/dictionary/test_autocmd_events.py

@@ -0,0 +1,25 @@
+import unittest
+from vint.ast.dictionary.autocmd_events import is_autocmd_event
+
+
+class TestAutocmdEvent(unittest.TestCase):
+    def test_is_autocmd_event(self):
+        test_cases = [
+            ('BufReadPost', True),
+            ('FileType', True),
+            ('FILETYPE', True),
+            ('filetype', True),
+            ('*', True),
+            ('INVALID', False),
+        ]
+
+        for (event_name, expected) in test_cases:
+            self.assertEqual(
+                is_autocmd_event(event_name),
+                expected,
+                msg="{event_name} should be {expected}".format(event_name=event_name, expected=expected)
+            )
+
+
+if __name__ == '__main__':
+    unittest.main()

test/unit/vint/ast/plugin/fixture_autocmd_parser_orthodox.vim

@@ -0,0 +1 @@
+autocmd! bufwritepost vimrc 

test/unit/vint/ast/plugin/fixture_autocmd_parser_with_line_continuation.vim

@@ -0,0 +1,5 @@
+" https://github.com/amix/vimrc
+autocmd BufReadPost *
+   \ if line("'\"") > 0 && line("'\"") <= line("$") |
+   \   exe "normal! g`\"" |
+   \ endif

test/unit/vint/ast/plugin/test_autocmd_parser.py

@@ -0,0 +1,180 @@
+import unittest
+from vint.ast.dictionary.autocmd_events import AutocmdEvents
+from vint.ast.plugin.autocmd_parser import parse_autocmd
+
+
+def create_echo_cmd_node():
+    return ':echo'
+
+
+def create_autocmd_node(autocmd_str):
+    return {'str': autocmd_str}
+
+
+class TestAutocmdParser(unittest.TestCase):
+    def test_parse_autocmd(self):
+        test_cases = [
+            (create_autocmd_node('autocmd'), {
+                'group': None,
+                'event': [],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': False,
+            }),
+            (create_autocmd_node('autocmd!'), {
+                'group': None,
+                'event': [],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': True,
+            }),
+            (create_autocmd_node('autocmd FileType'), {
+                'group': None,
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': False,
+            }),
+            (create_autocmd_node('autocmd BufNew,BufRead'), {
+                'group': None,
+                'event': [AutocmdEvents.BUF_NEW, AutocmdEvents.BUF_READ],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': False,
+            }),
+            (create_autocmd_node('autocmd! FileType'), {
+                'group': None,
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': True,
+            }),
+            (create_autocmd_node('autocmd FileType *'), {
+                'group': None,
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': '*',
+                'nested': False,
+                'cmd': None,
+                'bang': False,
+            }),
+            (create_autocmd_node('autocmd! FileType *'), {
+                'group': None,
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': '*',
+                'nested': False,
+                'cmd': None,
+                'bang': True,
+            }),
+            (create_autocmd_node('autocmd FileType * nested :echo'), {
+                'group': None,
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': '*',
+                'nested': True,
+                'cmd': create_echo_cmd_node(),
+                'bang': False,
+            }),
+            (create_autocmd_node('autocmd! FileType * nested :echo'), {
+                'group': None,
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': '*',
+                'nested': True,
+                'cmd': create_echo_cmd_node(),
+                'bang': True,
+            }),
+            (create_autocmd_node('autocmd Group'), {
+                'group': 'Group',
+                'event': [],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': False,
+            }),
+            (create_autocmd_node('autocmd! Group'), {
+                'group': 'Group',
+                'event': [],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': True,
+            }),
+            (create_autocmd_node('autocmd Group *'), {
+                'group': 'Group',
+                'event': [AutocmdEvents.ANY],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': False,
+            }),
+            (create_autocmd_node('autocmd! Group *'), {
+                'group': 'Group',
+                'event': [AutocmdEvents.ANY],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': True,
+            }),
+            (create_autocmd_node('autocmd Group FileType'), {
+                'group': 'Group',
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': False,
+            }),
+            (create_autocmd_node('autocmd! Group FileType'), {
+                'group': 'Group',
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': None,
+                'nested': False,
+                'cmd': None,
+                'bang': True,
+            }),
+            (create_autocmd_node('autocmd Group FileType *'), {
+                'group': 'Group',
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': '*',
+                'nested': False,
+                'cmd': None,
+                'bang': False,
+            }),
+            (create_autocmd_node('autocmd! Group FileType *'), {
+                'group': 'Group',
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': '*',
+                'nested': False,
+                'cmd': None,
+                'bang': True,
+            }),
+            (create_autocmd_node('autocmd Group FileType * nested :echo'), {
+                'group': 'Group',
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': '*',
+                'nested': True,
+                'cmd': create_echo_cmd_node(),
+                'bang': False,
+            }),
+            (create_autocmd_node('autocmd! Group FileType * nested :echo'), {
+                'group': 'Group',
+                'event': [AutocmdEvents.FILE_TYPE],
+                'pat': '*',
+                'nested': True,
+                'cmd': create_echo_cmd_node(),
+                'bang': True,
+            }),
+        ]
+
+        for (autocmd_str, expected) in test_cases:
+            self.assertEqual(
+                parse_autocmd(autocmd_str),
+                expected,
+                msg=autocmd_str
+            )
+
+
+if __name__ == '__main__':
+    unittest.main()

test/unit/vint/ast/test_node_type.py

@@ -1,11 +1,25 @@
 import unittest
-from vint.ast.node_type import NodeType
+from vint.ast.node_type import NodeType, get_node_type, is_node_type_of
 
 
 class TestNodeType(unittest.TestCase):
     def test_get_node_type_name(self):
         self.assertIs(NodeType(1), NodeType.TOPLEVEL)
         self.assertIs(NodeType(89), NodeType.REG)
 
+
+    def test_get_node_type(self):
+        node_stub = {'type': NodeType.TOPLEVEL.value}
+
+        self.assertEqual(get_node_type(node_stub), NodeType.TOPLEVEL)
+
+
+    def test_is_node_type_of(self):
+        node_stub = {'type': NodeType.TOPLEVEL.value}
+
+        self.assertTrue(is_node_type_of(NodeType.TOPLEVEL, node_stub))
+        self.assertFalse(is_node_type_of(NodeType.ECHO, node_stub))
+
+
 if __name__ == '__main__':
     unittest.main()

test/unit/vint/ast/test_traversing.py

@@ -1,19 +1,28 @@
 import unittest
+import enum
+from functools import partial
 from test.asserting.ast import get_fixture_path
 
 from vint.ast.parsing import Parser
-from vint.ast.node_type import NodeType
-from vint.ast.traversing import traverse, SKIP_CHILDREN
+from vint.ast.node_type import NodeType, is_node_type_of
+from vint.ast.traversing import traverse, SKIP_CHILDREN, find_all, find_first
 
-FIXTURE_FILE = get_fixture_path('fixture_to_traverse.vim')
+
+
+class Fixtures(enum.Enum):
+    FIND_ALL = get_fixture_path('fixture_traversing_find_all.vim')
+    TRAVERSING = get_fixture_path('fixture_to_traverse.vim')
 
 
 class TestTraverse(unittest.TestCase):
-    def setUp(self):
+    def create_ast(self, filepath):
         parser = Parser()
-        self.ast = parser.parse_file(FIXTURE_FILE)
+        return parser.parse_file(filepath.value)
+
 
     def test_traverse(self):
+        ast = self.create_ast(Fixtures.TRAVERSING)
+
         expected_order_of_events = [
             {'node_type': NodeType.TOPLEVEL, 'handler': 'enter'},
             {'node_type': NodeType.LET, 'handler': 'enter'},
@@ -49,7 +58,7 @@ def test_traverse(self):
 
         # Records visit node type name in order
         actual_order_of_events = []
-        traverse(self.ast,
+        traverse(ast,
                  on_enter=lambda node: actual_order_of_events.append({
                      'node_type': NodeType(node['type']),
                      'handler': 'enter',
@@ -64,6 +73,8 @@ def test_traverse(self):
 
 
     def test_traverse_ignoring_while_children(self):
+        ast = self.create_ast(Fixtures.TRAVERSING)
+
         expected_order_of_events = [
             {'node_type': NodeType.TOPLEVEL, 'handler': 'enter'},
             {'node_type': NodeType.LET, 'handler': 'enter'},
@@ -86,10 +97,9 @@ def on_enter(node):
             if NodeType(node['type']) is NodeType.WHILE:
                 return SKIP_CHILDREN
 
-
         # Records visit node type name in order
         actual_order_of_events = []
-        traverse(self.ast,
+        traverse(ast,
                  on_enter=on_enter,
                  on_leave=lambda node: actual_order_of_events.append({
                      'node_type': NodeType(node['type']),
@@ -100,5 +110,33 @@ def on_enter(node):
         self.assertEqual(actual_order_of_events, expected_order_of_events)
 
 
+    def test_find_all(self):
+        ast = self.create_ast(Fixtures.FIND_ALL)
+
+        found_nodes = find_all(NodeType.ECHO, ast)
+
+        is_let_node = partial(is_node_type_of, NodeType.ECHO)
+        are_let_nodes = all(map(is_let_node, found_nodes))
+
+        self.assertEqual(3, len(found_nodes))
+        self.assertTrue(are_let_nodes)
+
+
+    def test_find_with_existent_node_type(self):
+        ast = self.create_ast(Fixtures.FIND_ALL)
+
+        found_node = find_first(NodeType.ECHO, ast)
+
+        self.assertTrue(is_node_type_of(NodeType.ECHO, found_node))
+
+
+    def test_find_with_unexistent_node_type(self):
+        ast = self.create_ast(Fixtures.FIND_ALL)
+
+        found_node = find_first(NodeType.WHILE, ast)
+
+        self.assertEqual(found_node, None)
+
+
 if __name__ == '__main__':
     unittest.main()