Remove config functionality related to YAML files

Signed-off-by: John Pennycook <john.pennycook@intel.com>

Author: Pennycook

codebasin/config.py

@@ -6,14 +6,9 @@
 """
 
 import collections
-import glob
-import itertools as it
 import logging
 import os
 import re
-import warnings
-
-import yaml
 
 from codebasin import CompileCommand, util
 
@@ -75,109 +70,6 @@ def extract_include_files(argv):
     return includes
 
 
-def expand_path(pattern):
-    """
-    Return all valid and existing paths matching a specified pattern.
-    """
-    paths = glob.glob(pattern, recursive=True)
-    if paths == []:
-        log.warning(
-            "Couldn't find files matching '%s' -- ignoring it.",
-            pattern,
-        )
-    return [os.path.realpath(path) for path in filter(util.valid_path, paths)]
-
-
-def flatten(nested_list):
-    """
-    Flatten an arbitrarily nested list.
-    Nesting may occur when anchors are used inside a YAML list.
-    """
-    flattened = []
-    for item in nested_list:
-        if isinstance(item, list):
-            flattened.extend(flatten(item))
-        else:
-            flattened.append(item)
-    return flattened
-
-
-def load_codebase(config, rootdir, *, exclude_patterns=None):
-    """
-    Load the code base definition into a Python object.
-    Return a dict of files and platform names.
-    """
-    # Ensure expected values are present, or provide defaults
-    cfg_codebase = config["codebase"]
-    if not cfg_codebase:
-        raise RuntimeError("Empty 'codebase' section found in config file!")
-    if "files" not in cfg_codebase:
-        raise RuntimeError("No 'files' section found in codebase definition!")
-    if "platforms" not in cfg_codebase or cfg_codebase["platforms"] == []:
-        raise RuntimeError(
-            "Empty 'platforms' section found in codebase definition!",
-        )
-
-    codebase = {}
-
-    codebase["platforms"] = cfg_codebase["platforms"]
-
-    if "exclude_files" in cfg_codebase:
-        codebase["exclude_files"] = frozenset(
-            it.chain(
-                *(
-                    expand_path(os.path.join(rootdir, f))
-                    for f in cfg_codebase["exclude_files"]
-                ),
-            ),
-        )
-        warnings.warn(
-            "'exclude_files' is deprecated. Use 'exclude_pattern' instead.",
-        )
-    else:
-        codebase["exclude_files"] = frozenset([])
-
-    if "exclude_patterns" in cfg_codebase:
-        codebase["exclude_patterns"] = cfg_codebase["exclude_patterns"]
-    else:
-        codebase["exclude_patterns"] = []
-
-    if exclude_patterns:
-        codebase["exclude_patterns"] += exclude_patterns
-
-    if cfg_codebase["files"]:
-        codebase["files"] = list(
-            it.chain(
-                *(
-                    expand_path(os.path.join(rootdir, f))
-                    for f in cfg_codebase["files"]
-                ),
-            ),
-        )
-        if not codebase["files"]:
-            raise RuntimeError(
-                "Codebase configuration contains no valid files. "
-                + "Check regular expressions and working directory.",
-            )
-
-        codebase["files"] = list(
-            set(codebase["files"]).difference(codebase["exclude_files"]),
-        )
-        if not codebase["files"]:
-            raise RuntimeError(
-                "Codebase configuration contains no valid files "
-                + "after processing 'exclude_files'.",
-            )
-    else:
-        codebase["files"] = list([])
-        log.warning(
-            "No files specified in codebase configuration. "
-            + "Determining files automatically from platform configurations.",
-        )
-
-    return codebase
-
-
 _importcfg = None
 
 
@@ -500,146 +392,3 @@ def load_database(dbpath, rootdir):
         )
 
     return configuration
-
-
-def load_platform(config, rootdir, platform_name):
-    """
-    Load the platform specified by platform_name into a Python object.
-    Return a list of compilation commands, where each command is
-    represented as a compilation database entry.
-    """
-    # Ensure expected values are present, or provide defaults
-    cfg_platform = config[platform_name]
-    if not cfg_platform:
-        raise RuntimeError(
-            "Could not find definition for platform "
-            + f"'{platform_name}' in config file!",
-        )
-    if "files" not in cfg_platform and "commands" not in cfg_platform:
-        raise RuntimeError(
-            "Need 'files' or 'commands' section in "
-            + f"definition of platform {platform_name}!",
-        )
-    if "files" not in cfg_platform:
-        if "defines" in cfg_platform or "include_paths" in cfg_platform:
-            log.warning(
-                "Extra 'defines' or 'include_paths' in definition "
-                + f"of platform {platform_name}.",
-            )
-    else:
-        if "defines" not in cfg_platform:
-            cfg_platform["defines"] = []
-        if "include_paths" not in cfg_platform:
-            cfg_platform["include_paths"] = []
-
-    # Combine manually specified files, defines and includes
-    # into configuration entries
-    configuration = []
-    if "files" in cfg_platform:
-        include_paths = [
-            os.path.realpath(os.path.join(rootdir, f))
-            for f in flatten(cfg_platform["include_paths"])
-        ]
-
-        # Strip optional -D prefix from defines
-        defines = [
-            d[2:] if d.startswith("-D") else d
-            for d in flatten(cfg_platform["defines"])
-        ]
-
-        for f in flatten(cfg_platform["files"]):
-            for path in expand_path(os.path.join(rootdir, f)):
-                configuration += [
-                    {
-                        "file": path,
-                        "defines": defines,
-                        "include_paths": include_paths,
-                        "include_files": [],
-                    },
-                ]
-
-    # Add configuration entries from a compilation database
-    if "commands" in cfg_platform:
-        dbpath = os.path.realpath(
-            os.path.join(rootdir, cfg_platform["commands"]),
-        )
-        configuration += load_database(dbpath, rootdir)
-
-    # Ensure that the platform actually specifies valid files
-    if not configuration:
-        raise RuntimeError(
-            f"Platform '{platform_name!s}' contains no valid files -- "
-            + "regular expressions and/or working directory may be incorrect.",
-        )
-
-    return configuration
-
-
-def load(
-    config_file,
-    rootdir,
-    *,
-    exclude_patterns=None,
-    filtered_platforms=None,
-):
-    """
-    Load the configuration file into Python objects.
-    Return a (codebase, platform configuration) tuple of dicts.
-    """
-    if os.path.isfile(config_file):
-        with util.safe_open_read_nofollow(config_file, "r") as f:
-            config = yaml.safe_load(f)
-    else:
-        raise RuntimeError(f"Could not open {config_file!s}.")
-
-    # Validate config against a schema
-    util._validate_yaml(config, schema_name="config")
-
-    # Read codebase definition
-    if "codebase" in config:
-        codebase = load_codebase(
-            config,
-            rootdir,
-            exclude_patterns=exclude_patterns,
-        )
-    else:
-        raise RuntimeError("Missing 'codebase' section in config file!")
-
-    log.info("Platforms: %s", ", ".join(codebase["platforms"]))
-
-    # Limit the set of platforms in the codebase if requested.
-    if filtered_platforms:
-        for p in filtered_platforms:
-            if p not in codebase["platforms"]:
-                raise RuntimeError(
-                    f"Platform {p} requested on the command line "
-                    + "does not exist in the configuration file.",
-                )
-        codebase["platforms"] = filtered_platforms
-
-    # Read each platform definition and populate platform configuration
-    # If files was empty, populate it with the files we find here
-    populate_files = not codebase["files"]
-    found_files = set(codebase["files"])
-    configuration = collections.defaultdict(list)
-    for platform_name in codebase["platforms"]:
-        plat = load_platform(config, rootdir, platform_name)
-        if populate_files:
-            files = frozenset([p["file"] for p in plat])
-            found_files.update(files)
-        configuration[platform_name] = plat
-
-    if len(found_files) == 0:
-        raise RuntimeError(
-            "No files found. Check regular expressions and working directory.",
-        )
-
-    codebase["files"] = list(found_files.difference(codebase["exclude_files"]))
-    if not codebase["files"]:
-        raise RuntimeError("No files remain after processing 'exclude_files'.")
-
-    # Store the rootdir in the codebase for use later in exclude()
-    if "rootdir" not in codebase:
-        codebase["rootdir"] = os.path.realpath(rootdir)
-
-    return codebase, configuration