json: add support for 'arguments' [GH-3]

Arguments is now used by Bear, intercept-build and clang's -MJ flag.

Author: Sarcasm

compdb/backend/json.py

@@ -33,14 +33,17 @@ def get_all_files(self):
                 os.path.join(entry['directory'], entry['file']))
 
     def get_all_compile_commands(self):
-        # PERFORMANCE: I think shlex is inherently slow,
-        # something performing better may be necessary
         return map(self._dict_to_compile_command, self._data)
 
     @staticmethod
     def _dict_to_compile_command(d):
-        return CompileCommand(d['directory'], d['file'],
-                              shlex.split(d['command']))
+        if 'arguments' in d:
+            arguments = d['arguments']
+        else:
+            # PERFORMANCE: I think shlex is inherently slow,
+            # something performing better may be necessary
+            arguments = shlex.split(d['command'])
+        return CompileCommand(d['directory'], d['file'], arguments)
 
     @property
     def _data(self):

compdb/models.py

@@ -20,16 +20,27 @@ def __init__(self, directory, file, arguments):
         self.file = file
         self.arguments = arguments
 
+    @property
+    def normfile(self):
+        return os.path.normpath(os.path.join(self.directory, self.file))
+
     def __repr__(self):
         return "{{directory: {},\nfile: {},\n arguments: {}}}\n\n".format(
             self.directory, self.file, pprint.pformat(self.arguments))
 
     def __str__(self):
         return self.__repr__()
 
-    @property
-    def normfile(self):
-        return os.path.normpath(os.path.join(self.directory, self.file))
+    def _as_tuple(self):
+        return (self.directory, self.file, self.arguments)
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return self._as_tuple() == other._as_tuple()
+        return NotImplemented
+
+    def __ne__(self, other):
+        return not self == other
 
 
 class CompilationDatabaseInterface(object):
@@ -53,7 +64,10 @@ def get_compile_commands(self, filepath):
         raise compdb.NotImplementedError
 
     def get_all_files(self):
-        """Return an iterable of path strings."""
+        """Return an iterable of path strings.
+
+        A same path can be returned multiple times,
+        store the result in a set if uniqueness is required."""
         raise compdb.NotImplementedError
 
     def get_all_compile_commands(self):

tests/unit/backend/__init__.py

@@ -0,0 +1,44 @@
+from __future__ import print_function, unicode_literals, absolute_import
+
+import os
+import unittest
+
+from compdb.backend.json import JSONCompilationDatabase
+from compdb.models import CompileCommand
+
+
+class JSONCompilationDatabaseTest(unittest.TestCase):
+    LOCAL_PATH = os.path.abspath(os.path.dirname(__file__))
+    TEST_DIR = os.path.join(LOCAL_PATH, 'test_json_data')
+
+    def setUp(self):
+        self.db = JSONCompilationDatabase.probe_directory(self.TEST_DIR)
+
+    def tearDown(self):
+        self.db = None
+
+    def test_get_compile_commands(self):
+        a_commands = list(self.db.get_compile_commands("/tmp/a.cpp"))
+        self.assertEqual(len(a_commands), 1)
+        self.assertEqual(a_commands[0],
+                         CompileCommand("/tmp/", "/tmp/a.cpp",
+                                        ["clang", "-DA=1"]))
+        b_commands = list(self.db.get_compile_commands("/tmp/b.cpp"))
+        self.assertEqual(len(b_commands), 2)
+        self.assertEqual(b_commands[0],
+                         CompileCommand("/tmp/", "/tmp/b.cpp",
+                                        ["clang", "-DB=1"]))
+        self.assertEqual(b_commands[1],
+                         CompileCommand("/tmp/", "/tmp/b.cpp",
+                                        ["clang", "-DB=2"]))
+
+    def test_get_all_files(self):
+        files = list(sorted(self.db.get_all_files()))
+        self.assertEqual(
+            files,
+            [
+                '/tmp/a.cpp',
+                '/tmp/b.cpp',
+                # note: it's debatable whether duplicates should be present
+                '/tmp/b.cpp',
+            ])

tests/unit/backend/test_json.py

@@ -0,0 +1,17 @@
+[
+{
+    "directory": "/tmp/",
+    "command": "clang -DA=1",
+    "file": "/tmp/a.cpp"
+},
+{
+    "directory": "/tmp/",
+    "arguments": [ "clang", "-DB=1" ],
+    "file": "/tmp/b.cpp"
+},
+{
+    "directory": "/tmp/",
+    "arguments": [ "clang", "-DB=2" ],
+    "file": "/tmp/b.cpp"
+}
+]

tests/unit/backend/test_json_data/compile_commands.json

@@ -0,0 +1,21 @@
+from __future__ import print_function, unicode_literals, absolute_import
+
+import unittest
+
+from compdb.models import CompileCommand
+
+
+class CompileCommandTest(unittest.TestCase):
+    def test_comparable(self):
+        a1 = CompileCommand("/", "a.c", ["cc"])
+        a2 = CompileCommand("/", "a.c", ["cc"])
+        b = CompileCommand("/", "b.c", ["cc"])
+        self.assertTrue(a1 == a2)
+        self.assertFalse(a1 == b)
+        self.assertTrue(a1 != b)
+        self.assertFalse(a1 != a2)
+        self.assertEqual(a1, a2)
+
+
+if __name__ == "__main__":
+    unittest.main()