[NFC][Build System: build-script] Remove the old and unused preset parser.

utils/build-script

@@ -971,7 +971,7 @@ def main_preset():
         diagnostics.fatal(e.message)
 
     if args.show_presets:
-        for name in sorted(preset_parser.preset_names(),
+        for name in sorted(preset_parser.preset_names,
                            key=lambda name: name.lower()):
             print(name)
         return 0

utils/build_swift/build_swift/presets.py

@@ -11,6 +11,7 @@
 Swift preset parsing and handling functionality.
 """
 
+
 from __future__ import absolute_import, unicode_literals
 
 from collections import namedtuple
@@ -337,6 +338,7 @@ def get_preset(self, name, raw=False, vars=None):
 
         return preset
 
+    @property
     def preset_names(self):
         """Returns a list of all parsed preset names.
         """

utils/build_swift/tests/test_driver_arguments.py

@@ -10,18 +10,14 @@
 import os
 import platform
 import sys
-import unittest
-from contextlib import contextmanager
-from io import StringIO
-
-from swift_build_support.swift_build_support.SwiftBuildSupport import (
-    get_all_preset_names, get_preset_options)
 
 from . import expected_options as eo
-from .utils import BUILD_SCRIPT_IMPL_PATH, UTILS_PATH
+from . import utils
+from .utils import TestCase, UTILS_PATH, redirect_stdout
 from ..build_swift import argparse
 from ..build_swift import driver_arguments
 from ..build_swift import migration
+from ..build_swift.presets import PresetParser
 
 
 PRESETS_FILES = [
@@ -33,46 +29,22 @@ class ParserError(Exception):
     pass
 
 
-@contextmanager
-def redirect_stderr(stream=None):
-    stream = stream or StringIO()
-    old_stderr, sys.stderr = sys.stderr, stream
-    try:
-        yield stream
-    finally:
-        sys.stderr = old_stderr
-
-
-@contextmanager
-def redirect_stdout(stream=None):
-    stream = stream or StringIO()
-    old_stdout, sys.stdout = sys.stdout, stream
-    try:
-        yield stream
-    finally:
-        sys.stdout = old_stdout
-
-
-def _load_all_presets(presets_files):
-    preset_names = get_all_preset_names(presets_files)
+def _load_all_presets(preset_files):
+    parser = PresetParser()
+    parser.read(preset_files)
 
     # Hack to filter out mixins which are not expected to be valid presets
-    preset_names = [n for n in preset_names if not n.startswith('mixin')]
-
-    substitutions = {
-        'install_destdir': '/tmp/install',
-        'install_symroot': '/tmp/symroot',
-        'installable_package': '/tmp/xcode-xyz-root.tar.gz',
-    }
+    preset_names = [
+        name for name in parser.preset_names
+        if not name.startswith('mixin')
+    ]
 
     presets = dict()
     for name in preset_names:
-        try:
-            # Attempt to parse preset
-            presets[name] = get_preset_options(substitutions,
-                                               presets_files, name)
-        except SystemExit:
-            continue
+        preset = parser.get_preset(name, raw=True)
+        args = migration.migrate_swift_sdks(preset.format_args())
+
+        presets[name] = args
 
     return presets
 
@@ -351,15 +323,8 @@ def test(self):
         return test
 
 
-class TestDriverArgumentParser(unittest.TestCase):
-
-    __metaclass__ = TestDriverArgumentParserMeta
-
-    @contextmanager
-    def _quiet_output(self):
-        with open(os.devnull, 'w') as devnull:
-            with redirect_stderr(devnull), redirect_stdout(devnull):
-                yield
+@utils.add_metaclass(TestDriverArgumentParserMeta)
+class TestDriverArgumentParser(TestCase):
 
     def _parse_args(self, args):
         try:
@@ -372,8 +337,9 @@ def _check_impl_args(self, namespace):
         assert hasattr(namespace, 'build_script_impl_args')
 
         try:
-            migration.check_impl_args(BUILD_SCRIPT_IMPL_PATH,
-                                      namespace.build_script_impl_args)
+            migration.check_impl_args(
+                utils.BUILD_SCRIPT_IMPL_PATH,
+                namespace.build_script_impl_args)
         except (SystemExit, ValueError) as e:
             raise ParserError('failed to parse impl arguments: ' +
                               str(namespace.build_script_impl_args), e)
@@ -382,7 +348,7 @@ def parse_args_and_unknown_args(self, args, namespace=None):
         if namespace is None:
             namespace = argparse.Namespace()
 
-        with self._quiet_output():
+        with self.quietOutput():
             try:
                 namespace, unknown_args = (
                     super(self.parser.__class__, self.parser).parse_known_args(
@@ -396,32 +362,23 @@ def parse_args_and_unknown_args(self, args, namespace=None):
         return namespace, unknown_args
 
     def parse_args(self, args, namespace=None):
-        namespace, unknown_args = self.parse_args_and_unknown_args(args,
-                                                                   namespace)
+        namespace, unknown_args = self.parse_args_and_unknown_args(
+            args, namespace)
 
         if unknown_args:
             raise ParserError('unknown arguments: ' + str(unknown_args))
 
         return namespace
 
     def parse_default_args(self, args, check_impl_args=False):
-        with self._quiet_output():
+        with self.quietOutput():
             namespace = self._parse_args(args)
 
             if check_impl_args:
                 self._check_impl_args(namespace)
 
             return namespace
 
-    @contextmanager
-    def assertNotRaises(self, exception):
-        assert issubclass(exception, BaseException)
-
-        try:
-            yield
-        except exception as e:
-            self.fail(str(e))
-
     def setUp(self):
         self.parser = driver_arguments.create_argument_parser()
 

utils/build_swift/tests/test_presets.py

@@ -131,7 +131,7 @@ def __new__(cls, name, bases, attrs):
         preset_parser.read(PRESET_FILES)
 
         # Generate tests for each preset
-        for preset_name in preset_parser.preset_names():
+        for preset_name in preset_parser.preset_names:
             test_name = 'test_get_preset_' + preset_name
             attrs[test_name] = cls.generate_get_preset_test(
                 preset_parser, preset_name)
@@ -277,5 +277,5 @@ def test_preset_names(self):
         parser.read_string('[preset: bar]')
         parser.read_string('[preset: baz]')
 
-        self.assertEqual(set(parser.preset_names()),
+        self.assertEqual(set(parser.preset_names),
                          set(['foo', 'bar', 'baz']))

utils/swift_build_support/swift_build_support/SwiftBuildSupport.py

@@ -10,17 +10,8 @@
 
 from __future__ import print_function
 
-try:
-    # Python 2
-    import ConfigParser
-except ImportError:
-    # Python 3
-    import configparser as ConfigParser
-
 import os
 
-from . import diagnostics
-
 
 HOME = os.environ.get("HOME", "/")
 
@@ -86,123 +77,3 @@ def _get_default_swift_repo_name():
 # directory name that is used.
 SWIFT_REPO_NAME = os.environ.get(
     "SWIFT_REPO_NAME", _get_default_swift_repo_name())
-
-
-def _load_preset_files_impl(preset_file_names, substitutions={}):
-    config = ConfigParser.SafeConfigParser(substitutions, allow_no_value=True)
-    if config.read(preset_file_names) == []:
-        diagnostics.fatal(
-            "preset file not found (tried " + str(preset_file_names) + ")")
-    return config
-
-
-_PRESET_PREFIX = "preset: "
-
-
-def _get_preset_options_impl(config, substitutions, preset_name):
-    section_name = _PRESET_PREFIX + preset_name
-    if section_name not in config.sections():
-        return (None, None, None)
-
-    build_script_opts = []
-    build_script_impl_opts = []
-    missing_opts = []
-    dash_dash_seen = False
-
-    for o in config.options(section_name):
-        try:
-            a = config.get(section_name, o)
-        except ConfigParser.InterpolationMissingOptionError as e:
-            # e.reference contains the correctly formatted option
-            missing_opts.append(e.reference)
-            continue
-
-        if not a:
-            a = ""
-
-        if o in substitutions:
-            continue
-
-        opt = None
-        if o == "mixin-preset":
-            # Split on newlines and filter out empty lines.
-            mixins = filter(None, [m.strip() for m in a.splitlines()])
-            for mixin in mixins:
-                (base_build_script_opts,
-                    base_build_script_impl_opts,
-                    base_missing_opts) = \
-                    _get_preset_options_impl(config, substitutions, mixin)
-                build_script_opts += base_build_script_opts
-                build_script_impl_opts += base_build_script_impl_opts
-                missing_opts += base_missing_opts
-        elif o == "dash-dash":
-            dash_dash_seen = True
-        elif a == "":
-            opt = "--" + o
-        else:
-            opt = "--" + o + "=" + a
-
-        if opt:
-            if not dash_dash_seen:
-                build_script_opts.append(opt)
-            else:
-                build_script_impl_opts.append(opt)
-
-    return (build_script_opts, build_script_impl_opts, missing_opts)
-
-
-def get_preset_options(substitutions, preset_file_names, preset_name):
-    config = _load_preset_files_impl(preset_file_names, substitutions)
-
-    (build_script_opts, build_script_impl_opts, missing_opts) = \
-        _get_preset_options_impl(config, substitutions, preset_name)
-    if not build_script_opts and not build_script_impl_opts:
-        diagnostics.fatal("preset '" + preset_name + "' not found")
-    if missing_opts:
-        diagnostics.fatal("missing option(s) for preset '" + preset_name +
-                          "': " + ", ".join(missing_opts))
-
-    # Migrate 'swift-sdks' parameter to 'stdlib-deployment-targets'
-    swift_sdks_opts = [opt for opt in build_script_impl_opts
-                       if opt.startswith("--swift-sdks")]
-    try:
-        swift_sdks_opt = swift_sdks_opts[-1]
-    except IndexError:
-        swift_sdks_opt = None
-
-    if swift_sdks_opt is not None:
-        sdks_to_configure = swift_sdks_opt.split("=")[1].split(";")
-        tgts = []
-        # Expand SDKs in to their deployment targets
-        from swift_build_support.swift_build_support.targets \
-            import StdlibDeploymentTarget
-        for sdk in sdks_to_configure:
-            if sdk == "OSX":
-                tgts += StdlibDeploymentTarget.OSX.targets
-            elif sdk == "IOS":
-                tgts += StdlibDeploymentTarget.iOS.targets
-            elif sdk == "IOS_SIMULATOR":
-                tgts += StdlibDeploymentTarget.iOSSimulator.targets
-            elif sdk == "TVOS":
-                tgts += StdlibDeploymentTarget.AppleTV.targets
-            elif sdk == "TVOS_SIMULATOR":
-                tgts += StdlibDeploymentTarget.AppleTVSimulator.targets
-            elif sdk == "WATCHOS":
-                tgts += StdlibDeploymentTarget.AppleWatch.targets
-            elif sdk == "WATCHOS_SIMULATOR":
-                tgts += StdlibDeploymentTarget.AppleWatchSimulator.targets
-
-        build_script_opts.append("--stdlib-deployment-targets=" +
-                                 " ".join([tgt.name for tgt in tgts]))
-
-    # Filter the swift-sdks parameter
-    build_script_impl_opts = [opt for opt in build_script_impl_opts
-                              if not opt.startswith("--swift-sdks")]
-
-    return build_script_opts + ["--"] + build_script_impl_opts
-
-
-def get_all_preset_names(preset_file_names):
-    config = _load_preset_files_impl(preset_file_names)
-    return [name[len(_PRESET_PREFIX):] for name in config.sections()
-            if name.startswith(_PRESET_PREFIX)]