Check outdated packages for development platform

platformio/commands/platform.py

@@ -336,9 +336,13 @@ def platform_update(platforms, only_packages, only_check, json_output):
     app.clean_cache()
 
     pm = PlatformManager()
+    pkg_dir_to_name = {}
     if not platforms:
         platforms = []
-        platforms = [manifest['__pkg_dir'] for manifest in pm.get_installed()]
+        for manifest in pm.get_installed():
+            platforms.append(manifest['__pkg_dir'])
+            pkg_dir_to_name[manifest['__pkg_dir']] = manifest.get(
+                "title", manifest['name'])
 
     if only_check and json_output:
         result = []
@@ -352,16 +356,19 @@ def platform_update(platforms, only_packages, only_check, json_output):
             if not pkg_dir:
                 continue
             latest = pm.outdated(pkg_dir, requirements)
-            if not latest:
+            if (not latest and not PlatformFactory.newPlatform(pkg_dir)
+                    .are_outdated_packages()):
                 continue
             data = _get_installed_platform_data(
                 pkg_dir, with_boards=False, expose_packages=False)
-            data['versionLatest'] = latest
+            if latest:
+                data['versionLatest'] = latest
             result.append(data)
         return click.echo(json.dumps(result))
     else:
         for platform in platforms:
-            click.echo("Platform %s" % click.style(platform, fg="cyan"))
+            click.echo("Platform %s" % click.style(
+                pkg_dir_to_name.get(platform, platform), fg="cyan"))
             click.echo("--------")
             pm.update(
                 platform, only_packages=only_packages, only_check=only_check)

platformio/maintenance.py

@@ -30,7 +30,7 @@ from platformio.commands.platform import \
 from platformio.commands.platform import platform_update as cmd_platform_update
 from platformio.commands.upgrade import get_latest_version
 from platformio.managers.lib import LibraryManager
-from platformio.managers.platform import PlatformManager
+from platformio.managers.platform import PlatformFactory, PlatformManager
 from platformio.pioplus import pioplus_update
 
 
@@ -260,8 +260,14 @@ def check_internal_updates(ctx, what):
     pm = PlatformManager() if what == "platforms" else LibraryManager()
     outdated_items = []
     for manifest in pm.get_installed():
-        if manifest['name'] not in outdated_items and \
+        if manifest['name'] in outdated_items:
-                pm.outdated(manifest['__pkg_dir']):
+            continue
+        conds = [
+            pm.outdated(manifest['__pkg_dir']), what == "platforms" and
+            PlatformFactory.newPlatform(
+                manifest['__pkg_dir']).are_outdated_packages()
+        ]
+        if any(conds):
             outdated_items.append(manifest['name'])
 
     if not outdated_items:

platformio/managers/package.py

@@ -547,6 +547,7 @@ class BasePkgManager(PkgRepoMixin, PkgInstallerMixin):
         `False` - package is up-to-date
         `String` - a found latest version
         """
+        assert isdir(pkg_dir)
         latest = None
         manifest = self.load_manifest(pkg_dir)
         # skip a fixed package to a specific version
@@ -709,7 +710,7 @@ class BasePkgManager(PkgRepoMixin, PkgInstallerMixin):
             return
 
         if "__src_url" in manifest:
-            vcs = VCSClientFactory.newClient(pkg_dir, manifest['__vcs_url'])
+            vcs = VCSClientFactory.newClient(pkg_dir, manifest['__src_url'])
             assert vcs.update()
             self._update_src_manifest(
                 dict(version=vcs.get_current_revision()), vcs.storage_dir)

platformio/managers/platform.py

@@ -253,45 +253,29 @@ class PlatformPackagesMixin(object):
 
         return True
 
+    def update_packages(self, only_check=False):
+        for name, manifest in self.get_installed_packages().items():
+            version = self.packages[name].get("version", "")
+            if "@" in version:
+                _, version = version.rsplit("@", 1)
+            self.pm.update(manifest['__pkg_dir'], version, only_check)
+
     def get_installed_packages(self):
         items = {}
-        for name, opts in self.packages.items():
+        for name in self.packages:
-            version = opts.get("version", "")
+            pkg_dir = self.get_package_dir(name)
-            if self.is_valid_requirements(version):
+            if pkg_dir:
-                package = self.pm.get_package(name, version)
+                items[name] = self.pm.load_manifest(pkg_dir)
-            else:
-                package = self.pm.get_package(*self._parse_pkg_input(name,
-                                                                     version))
-            if package:
-                items[name] = package
         return items
 
-    def update_packages(self, only_check=False):
+    def are_outdated_packages(self):
-        for name in self.get_installed_packages():
+        for name, manifest in self.get_installed_packages().items():
             version = self.packages[name].get("version", "")
-            if self.is_valid_requirements(version):
+            if "@" in version:
-                self.pm.update(name, version, only_check)
+                _, version = version.rsplit("@", 1)
-            else:
+            if self.pm.outdated(manifest['__pkg_dir'], version):
-                requirements = None
+                return True
-                if "@" in version:
+        return False
-                    version, requirements = version.rsplit("@", 1)
-                self.pm.update("%s=%s" % (name, version), requirements,
-                               only_check)
-
-    # def are_outdated_packages(self):
-    #     latest = None
-    #     for name in self.get_installed_packages():
-    #         version = self.packages[name].get("version", "")
-    #         if self.is_valid_requirements(version):
-    #             latest = self.pm.outdated(name, version)
-    #         else:
-    #             requirements = None
-    #             if "@" in version:
-    #                 version, requirements = version.rsplit("@", 1)
-    #             latest = self.pm.outdated(name, requirements, version)
-    #         if latest or latest is None:
-    #             return True
-    #     return False
 
     def get_package_dir(self, name):
         version = self.packages[name].get("version", "")
@@ -302,13 +286,10 @@ class PlatformPackagesMixin(object):
                                                                   version))
 
     def get_package_version(self, name):
-        version = self.packages[name].get("version", "")
+        pkg_dir = self.get_package_dir(name)
-        if self.is_valid_requirements(version):
+        if not pkg_dir:
-            package = self.pm.get_package(name, version)
+            return None
-        else:
+        return self.pm.load_manifest(pkg_dir).get("version")
-            package = self.pm.get_package(*self._parse_pkg_input(name,
-                                                                 version))
-        return package['version'] if package else None
 
     @staticmethod
     def is_valid_requirements(requirements):