Refactor platform-related calls to PlatformFactory.from_env

platformio/builder/main.py

@@ -38,7 +38,6 @@ AllowSubstExceptions(NameError)
 # append CLI arguments to build environment
 clivars = Variables(None)
 clivars.AddVariables(
-    ("PLATFORM_MANIFEST",),
     ("BUILD_SCRIPT",),
     ("PROJECT_CONFIG",),
     ("PIOENV",),

platformio/builder/tools/pioplatform.py

@@ -33,9 +33,7 @@ from platformio.project.config import ProjectOptions
 @util.memoized()
 def _PioPlatform():
     env = DefaultEnvironment()
-    p = PlatformFactory.new(os.path.dirname(env["PLATFORM_MANIFEST"]))
+    return PlatformFactory.from_env(env["PIOENV"], targets=COMMAND_LINE_TARGETS)
-    p.configure_project_packages(env["PIOENV"], COMMAND_LINE_TARGETS)
-    return p
 
 
 def PioPlatform(_):

platformio/debug/cli.py

@@ -109,9 +109,7 @@ def cli(
 
 
 def _configure(ctx, project_config, env_name, load_mode, verbose, __unprocessed):
-    platform = PlatformFactory.new(
+    platform = PlatformFactory.from_env(env_name, autoinstall=True)
-        project_config.get(f"env:{env_name}", "platform"), autoinstall=True
-    )
     debug_config = DebugConfigFactory.new(
         platform,
         project_config,

platformio/package/commands/install.py

@@ -206,7 +206,7 @@ def _install_project_env_libraries(project_env, options):
     config = ProjectConfig.get_instance()
 
     compatibility_qualifiers = {}
-    if config.get(f"env:{project_env}", "platform"):
+    if config.get(f"env:{project_env}", "platform", None):
         try:
             p = PlatformFactory.new(config.get(f"env:{project_env}", "platform"))
             compatibility_qualifiers["platforms"] = [p.name]

platformio/package/commands/list.py

@@ -22,6 +22,7 @@ from platformio.package.manager.library import LibraryPackageManager
 from platformio.package.manager.platform import PlatformPackageManager
 from platformio.package.manager.tool import ToolPackageManager
 from platformio.package.meta import PackageItem, PackageSpec
+from platformio.platform.exception import UnknownPlatform
 from platformio.platform.factory import PlatformFactory
 from platformio.project.config import ProjectConfig
 
@@ -187,20 +188,20 @@ def list_project_packages(options):
 
 
 def print_project_env_platform_packages(project_env, options):
-    config = ProjectConfig.get_instance()
+    try:
-    platform = config.get(f"env:{project_env}", "platform")
+        p = PlatformFactory.from_env(project_env)
-    if not platform:
+    except UnknownPlatform:
-        return None
-    pkg = PlatformPackageManager().get_package(platform)
-    if not pkg:
         return None
     click.echo(
         "Platform %s"
-        % (humanize_package(pkg, platform, verbose=options.get("verbose")))
+        % (
+            humanize_package(
+                PlatformPackageManager().get_package(p.get_dir()),
+                p.config.get(f"env:{project_env}", "platform"),
+                verbose=options.get("verbose"),
+            )
+        )
     )
-    p = PlatformFactory.new(pkg)
-    if project_env:
-        p.configure_project_packages(project_env)
     print_dependency_tree(
         p.pm,
         specs=[p.get_package_spec(name) for name in p.packages],

platformio/package/commands/outdated.py

@@ -62,10 +62,9 @@ class OutdatedCandidate:
 )
 @click.option("-e", "--environment", "environments", multiple=True)
 def package_outdated_cmd(project_dir, environments):
-    candidates = fetch_outdated_candidates(
+    with fs.cd(project_dir):
-        project_dir, environments, with_progress=True
+        candidates = fetch_outdated_candidates(environments, with_progress=True)
-    )
+        print_outdated_candidates(candidates)
-    print_outdated_candidates(candidates)
 
 
 def print_outdated_candidates(candidates):
@@ -126,8 +125,10 @@ def get_candidate_update_color(outdated):
     return None
 
 
-def fetch_outdated_candidates(project_dir, environments, with_progress=False):
+def fetch_outdated_candidates(environments, with_progress=False):
     candidates = []
+    config = ProjectConfig.get_instance()
+    config.validate(environments)
 
     def _add_candidate(data):
         new_candidate = OutdatedCandidate(
@@ -139,20 +140,16 @@ def fetch_outdated_candidates(project_dir, environments, with_progress=False):
                 return
         candidates.append(new_candidate)
 
-    with fs.cd(project_dir):
+    # platforms
-        config = ProjectConfig.get_instance()
+    for item in find_platform_candidates(config, environments):
-        config.validate(environments)
+        _add_candidate(item)
+        # platform package dependencies
+        for dep_item in find_platform_dependency_candidates(item["env"]):
+            _add_candidate(dep_item)
 
-        # platforms
+    # libraries
-        for item in find_platform_candidates(config, environments):
+    for item in find_library_candidates(config, environments):
-            _add_candidate(item)
+        _add_candidate(item)
-            # platform package dependencies
-            for dep_item in find_platform_dependency_candidates(item):
-                _add_candidate(dep_item)
-
-        # libraries
-        for item in find_library_candidates(config, environments):
-            _add_candidate(item)
 
     result = []
     if not with_progress:
@@ -172,7 +169,7 @@ def find_platform_candidates(config, environments):
     result = []
     pm = PlatformPackageManager()
     for env in config.envs():
-        platform = config.get(f"env:{env}", "platform")
+        platform = config.get(f"env:{env}", "platform", None)
         if not platform or (environments and env not in environments):
             continue
         spec = PackageSpec(platform)
@@ -183,14 +180,13 @@ def find_platform_candidates(config, environments):
     return result
 
 
-def find_platform_dependency_candidates(platform_candidate):
+def find_platform_dependency_candidates(env):
     result = []
-    p = PlatformFactory.new(platform_candidate["spec"])
+    p = PlatformFactory.from_env(env)
-    p.configure_project_packages(platform_candidate["env"])
     for pkg in p.get_installed_packages():
         result.append(
             dict(
-                env=platform_candidate["env"],
+                env=env,
                 pm=p.pm,
                 pkg=pkg,
                 spec=p.get_package_spec(pkg.metadata.name),

platformio/platform/_run.py

@@ -51,13 +51,10 @@ class PlatformRunMixin:
         assert isinstance(targets, list)
 
         self.ensure_engine_compatible()
-        self.configure_project_packages(variables["pioenv"], targets)
 
         self.silent = silent
         self.verbose = verbose or app.get_setting("force_verbose")
 
-        variables["platform_manifest"] = self.manifest_path
-
         if "build_script" not in variables:
             variables["build_script"] = self.get_build_script()
         if not os.path.isfile(variables["build_script"]):

platformio/platform/base.py

@@ -34,6 +34,7 @@ class PlatformBase(  # pylint: disable=too-many-instance-attributes,too-many-pub
 
     def __init__(self, manifest_path):
         self.manifest_path = manifest_path
+        self.project_env = None  # set by factory.from_env(env)
         self.silent = False
         self.verbose = False
 

platformio/platform/factory.py

@@ -21,6 +21,8 @@ from platformio.compat import load_python_module
 from platformio.package.meta import PackageItem
 from platformio.platform import base
 from platformio.platform.exception import UnknownPlatform
+from platformio.project.config import ProjectConfig
+from platformio.project.exception import UndefinedEnvPlatformError
 
 
 class PlatformFactory:
@@ -88,3 +90,14 @@ class PlatformFactory:
         _instance = platform_cls(os.path.join(platform_dir, "platform.json"))
         assert isinstance(_instance, base.PlatformBase)
         return _instance
+
+    @classmethod
+    def from_env(cls, env, targets=None, autoinstall=False):
+        config = ProjectConfig.get_instance()
+        spec = config.get(f"env:{env}", "platform", None)
+        if not spec:
+            raise UndefinedEnvPlatformError(env)
+        p = cls.new(spec, autoinstall=autoinstall)
+        p.project_env = env
+        p.configure_project_packages(env, targets)
+        return p

platformio/project/commands/init.py

@@ -26,6 +26,7 @@ from platformio.package.manager.platform import PlatformPackageManager
 from platformio.platform.exception import UnknownBoard
 from platformio.platform.factory import PlatformFactory
 from platformio.project.config import ProjectConfig
+from platformio.project.exception import UndefinedEnvPlatformError
 from platformio.project.helpers import is_platformio_project
 from platformio.project.integration.generator import ProjectGenerator
 from platformio.project.options import ProjectOptions
@@ -366,13 +367,10 @@ def update_project_env(environment, extra_project_options=None):
 
 
 def init_sample_code(config, environment):
-    platform_spec = config.get(f"env:{environment}", "platform", None)
-    if not platform_spec:
-        return None
-    p = PlatformFactory.new(platform_spec)
     try:
+        p = PlatformFactory.from_env(environment)
         return p.generate_sample_code(config, environment)
-    except NotImplementedError:
+    except (NotImplementedError, UndefinedEnvPlatformError):
         pass
 
     framework = config.get(f"env:{environment}", "framework", None)

platformio/run/processor.py

@@ -72,8 +72,8 @@ class EnvironmentProcessor:
 
         # pre-clean
         if is_clean:
-            result = PlatformFactory.new(
+            result = PlatformFactory.from_env(
-                self.options["platform"], autoinstall=True
+                self.name, targets=self.targets, autoinstall=True
             ).run(build_vars, self.targets, self.silent, self.verbose, self.jobs)
             if not build_targets:
                 return result["returncode"] == 0
@@ -85,7 +85,7 @@ class EnvironmentProcessor:
                 "piotest_running_name": build_vars.get("piotest_running_name"),
             },
         )
-        result = PlatformFactory.new(self.options["platform"], autoinstall=True).run(
+        result = PlatformFactory.from_env(
-            build_vars, build_targets, self.silent, self.verbose, self.jobs
+            self.name, targets=build_targets, autoinstall=True
-        )
+        ).run(build_vars, build_targets, self.silent, self.verbose, self.jobs)
         return result["returncode"] == 0

platformio/test/runners/base.py

@@ -62,8 +62,8 @@ class TestRunnerBase:
         self.test_suite = test_suite
         self.options = options
         self.project_config = project_config
-        self.platform = PlatformFactory.new(
+        self.platform = PlatformFactory.from_env(
-            self.project_config.get(f"env:{self.test_suite.env_name}", "platform"),
+            self.test_suite.env_name,
             autoinstall=True,
         )
         self.cmd_ctx = None