Merge pull request #3246 from justbennet/sort-list-toolchains

Adding sorting to rst output of list_toolchains to match txt and none

Author: boegel

easybuild/tools/docs.py

@@ -744,28 +744,59 @@ def list_toolchains_rst(tcs):
     """ Returns overview of all toolchains in rst format """
     title = "List of known toolchains"
 
-    # figure out column names
-    table_titles = ['name', 'compiler', 'MPI']
-    for tc in tcs.values():
-        table_titles.extend(tc.keys())
+    # Specify the column names for the table
+    table_titles = ['NAME', 'COMPILER', 'MPI', 'LINALG', 'FFT']
 
+    # Set up column name : display name pairs
     col_names = {
-        'COMPILER_CUDA': 'CUDA compiler',
-        'SCALAPACK': 'ScaLAPACK',
+        'NAME': 'Name',
+        'COMPILER': 'Compiler(s)',
+        'LINALG': "Linear algebra",
     }
 
-    table_titles = nub(table_titles)
+    # Create sorted list of toolchain names
+    sorted_tc_names = sorted(tcs.keys(), key=str.lower)
 
-    table_values = [[] for i in range(len(table_titles))]
-    table_values[0] = ['**%s**' % tcname for tcname in tcs.keys()]
+    # Create text placeholder to use for missing entries
+    none_txt = '*(none)*'
 
-    for idx in range(1, len(table_titles)):
-        for tc in tcs.values():
-            table_values[idx].append(', '.join(tc.get(table_titles[idx].upper(), [])))
+    # Initialize an empty list of lists for the table data
+    table_values = [[] for i in range(len(table_titles))]
 
+    for col_id, col_name in enumerate(table_titles):
+        if col_name == 'NAME':
+            # toolchain names column gets bold face entry
+            table_values[col_id] = ['**%s**' % tcname for tcname in sorted_tc_names]
+        else:
+            for tc_name in sorted_tc_names:
+                tc = tcs[tc_name]
+                if 'cray' in tc_name.lower():
+                    if col_name == 'COMPILER':
+                        entry = ', '.join(tc[col_name.upper()])
+                    elif col_name == 'MPI':
+                        entry = 'cray-mpich'
+                    elif col_name == 'LINALG':
+                        entry = 'cray-libsci'
+                # Combine the linear algebra libraries into a single column
+                elif col_name == 'LINALG':
+                    linalg = []
+                    for col in ['BLAS', 'LAPACK', 'SCALAPACK']:
+                        linalg.extend(tc.get(col, []))
+                    entry = ', '.join(nub(linalg)) or none_txt
+                else:
+                    # for other columns, we can grab the values via 'tc'
+                    # key = col_name
+                    entry = ', '.join(tc.get(col_name, [])) or none_txt
+                table_values[col_id].append(entry)
+
+    # Set the table titles to the pretty ones
     table_titles = [col_names.get(col, col) for col in table_titles]
+
+    # Pass the data to the rst formatter, wich is returned as a list, each element
+    # is an rst formatted text row.
     doc = rst_title_and_table(title, table_titles, table_values)
 
+    # Make a string with line endings suitable to write to document file
     return '\n'.join(doc)
 
 

test/framework/options.py

@@ -517,6 +517,58 @@ def test__list_toolchains(self):
         if os.path.exists(dummylogfn):
             os.remove(dummylogfn)
 
+    def test_list_toolchains_rst(self):
+        """Test --list-toolchains --output-format=rst."""
+
+        args = [
+            '--list-toolchains',
+            '--output-format=rst',
+        ]
+        self.mock_stderr(True)
+        self.mock_stdout(True)
+        self.eb_main(args, raise_error=True)
+        stderr, stdout = self.get_stderr(), self.get_stdout().strip()
+        self.mock_stderr(False)
+        self.mock_stdout(False)
+
+        self.assertFalse(stderr)
+
+        title = "List of known toolchains"
+
+        # separator line: starts/ends with sequence of '=', 4 spaces in between columns
+        sep_line = r'=(=+\s{4})+[=]+='
+
+        col_names = ['Name', r'Compiler\(s\)', 'MPI', 'Linear algebra', 'FFT']
+        col_names_line = r'\s+'.join(col_names) + r'\s*'
+
+        patterns = [
+            # title
+            '^' + title + '\n' + '-' * len(title) + '\n',
+            # header
+            '\n' + '\n'.join([sep_line, col_names_line, sep_line]) + '\n',
+            # compiler-only GCC toolchain
+            r"\n\*\*GCC\*\*\s+GCC\s+\*\(none\)\*\s+\*\(none\)\*\s+\*\(none\)\*\s*\n",
+            # gompi compiler + MPI toolchain
+            r"\n\*\*gompi\*\*\s+GCC\s+OpenMPI\s+\*\(none\)\*\s+\*\(none\)\*\s*\n",
+            # full 'foss' toolchain
+            r"\*\*foss\*\*\s+GCC\s+OpenMPI\s+OpenBLAS,\s+ScaLAPACK\s+FFTW\s*\n",
+            # compiler-only iccifort toolchain
+            r"\*\*iccifort\*\*\s+icc,\s+ifort\s+\*\(none\)\*\s+\*\(none\)\*\s+\*\(none\)\*\s*\n",
+            # full 'intel' toolchain (imkl appears twice, in linalg + FFT columns)
+            r"\*\*intel\*\*\s+icc,\s+ifort\s+impi\s+imkl\s+imkl\s*\n",
+            # fosscuda toolchain, also lists CUDA in compilers column
+            r"\*\*fosscuda\*\*\s+GCC,\s+CUDA\s+OpenMPI\s+OpenBLAS,\s+ScaLAPACK\s+FFTW\s*\n",
+            # system toolchain: 'none' in every column
+            r"\*\*system\*\*\s+\*\(none\)\*\s+\*\(none\)\*\s+\*\(none\)\*\s+\*\(none\)\*\s*\n",
+            # Cray special case
+            r"\n\*\*CrayGNU\*\*\s+PrgEnv-gnu\s+cray-mpich\s+cray-libsci\s+\*\(none\)\*\s*\n",
+            # footer
+            '\n' + sep_line + '$',
+        ]
+        for pattern in patterns:
+            regex = re.compile(pattern, re.M)
+            self.assertTrue(regex.search(stdout), "Pattern '%s' should be found in: %s" % (regex.pattern, stdout))
+
     def test_avail_lists(self):
         """Test listing available values of certain types."""