Cleanup PackageManager

platformio/commands/lib.py

@@ -252,14 +252,14 @@ def lib_list(lm, json_output):
 @click.argument("library", metavar="[LIBRARY]")
 def lib_show(lm, library):  # pylint: disable=too-many-branches
     name, requirements, url = lm.parse_pkg_name(library)
-    installed_dir = lm.get_installed_dir(name, requirements, url)
+    package_dir = lm.get_package_dir(name, requirements, url)
-    if not installed_dir:
+    if not package_dir:
         click.secho(
             "%s @ %s is not installed" % (name, requirements or "*"),
             fg="yellow")
         return
 
-    manifest = lm.load_manifest(installed_dir)
+    manifest = lm.load_manifest(package_dir)
 
     click.secho(manifest['name'], fg="cyan")
     click.echo("=" * len(manifest['name']))

platformio/managers/lib.py

@@ -114,9 +114,9 @@ class LibraryManager(BasePkgManager):
         if name.startswith("id="):
             return int(name[3:])
         # try to find ID from installed packages
-        installed_dir = self.get_installed_dir(name, requirements)
+        package_dir = self.get_package_dir(name, requirements)
-        if installed_dir:
+        if package_dir:
-            manifest = self.load_manifest(installed_dir)
+            manifest = self.load_manifest(package_dir)
             if "id" in manifest:
                 return int(manifest['id'])
         return int(
@@ -151,7 +151,7 @@ class LibraryManager(BasePkgManager):
         if not _url:
             _name = "id=%d" % self._get_pkg_id_by_name(
                 _name, _requirements, silent=silent, interactive=interactive)
-        already_installed = self.get_installed_dir(_name, _requirements, _url)
+        already_installed = self.get_package(_name, _requirements, _url)
         pkg_dir = BasePkgManager.install(self, _name if not _url else name,
                                          _requirements, silent, trigger_event)
 

platformio/managers/package.py

@@ -370,7 +370,7 @@ class BasePkgManager(PkgRepoMixin, PkgInstallerMixin):
         BasePkgManager._INSTALLED_CACHE[self.package_dir] = items
         return items
 
-    def get_installed_dir(self, name, requirements=None, url=None):
+    def get_package(self, name, requirements=None, url=None):
         pkg_id = int(name[3:]) if name.startswith("id=") else 0
         best = None
         reqspec = None
@@ -406,19 +406,23 @@ class BasePkgManager(PkgRepoMixin, PkgInstallerMixin):
             # check that URL is the same in installed package (VCS)
             if url and best.get("url") != url:
                 return None
-            return best.get("__pkg_dir")
+            return best
         return None
 
+    def get_package_dir(self, name, requirements=None, url=None):
+        package = self.get_package(name, requirements, url)
+        return package.get("__pkg_dir") if package else None
+
     def is_outdated(self, name, requirements=None):
-        installed_dir = self.get_installed_dir(name, requirements)
+        package_dir = self.get_package_dir(name, requirements)
-        if not installed_dir:
+        if not package_dir:
             click.secho(
                 "%s @ %s is not installed" % (name, requirements or "*"),
                 fg="yellow")
             return
-        if self.get_vcs_manifest_path(installed_dir):
+        if self.get_vcs_manifest_path(package_dir):
             return False
-        manifest = self.load_manifest(installed_dir)
+        manifest = self.load_manifest(package_dir)
         return manifest['version'] != self.get_latest_repo_version(
             name, requirements)
 
@@ -429,20 +433,20 @@ class BasePkgManager(PkgRepoMixin, PkgInstallerMixin):
                 trigger_event=True,
                 interactive=False):  # pylint: disable=unused-argument
         name, requirements, url = self.parse_pkg_name(name, requirements)
-        installed_dir = self.get_installed_dir(name, requirements, url)
+        package_dir = self.get_package_dir(name, requirements, url)
 
-        if not installed_dir or not silent:
+        if not package_dir or not silent:
             msg = "Installing " + click.style(name, fg="cyan")
             if requirements:
                 msg += " @ " + requirements
             self.print_message(msg)
-        if installed_dir:
+        if package_dir:
             if not silent:
                 click.secho(
                     "{name} @ {version} is already installed".format(
-                        **self.load_manifest(installed_dir)),
+                        **self.load_manifest(package_dir)),
                     fg="yellow")
-            return installed_dir
+            return package_dir
 
         if url:
             pkg_dir = self._install_from_url(name, url, requirements)
@@ -470,24 +474,24 @@ class BasePkgManager(PkgRepoMixin, PkgInstallerMixin):
 
     def uninstall(self, name, requirements=None, trigger_event=True):
         name, requirements, url = self.parse_pkg_name(name, requirements)
-        installed_dir = self.get_installed_dir(name, requirements, url)
+        package_dir = self.get_package_dir(name, requirements, url)
-        if not installed_dir:
+        if not package_dir:
             click.secho(
                 "%s @ %s is not installed" % (name, requirements or "*"),
                 fg="yellow")
             return
 
-        manifest = self.load_manifest(installed_dir)
+        manifest = self.load_manifest(package_dir)
         click.echo(
             "Uninstalling %s @ %s: \t" % (click.style(
                 manifest['name'], fg="cyan"), manifest['version']),
             nl=False)
 
-        if isdir(installed_dir):
+        if isdir(package_dir):
-            if islink(installed_dir):
+            if islink(package_dir):
-                os.unlink(installed_dir)
+                os.unlink(package_dir)
             else:
-                util.rmtree_(installed_dir)
+                util.rmtree_(package_dir)
 
         click.echo("[%s]" % click.style("OK", fg="green"))
 
@@ -501,19 +505,19 @@ class BasePkgManager(PkgRepoMixin, PkgInstallerMixin):
 
     def update(self, name, requirements=None, only_check=False):
         name, requirements, url = self.parse_pkg_name(name, requirements)
-        installed_dir = self.get_installed_dir(name, requirements, url)
+        package_dir = self.get_package_dir(name, requirements, url)
-        if not installed_dir:
+        if not package_dir:
             click.secho(
                 "%s @ %s is not installed" % (name, requirements or "*"),
                 fg="yellow")
             return
 
         is_vcs_pkg = False
-        if self.get_vcs_manifest_path(installed_dir):
+        if self.get_vcs_manifest_path(package_dir):
             is_vcs_pkg = True
-            manifest_path = self.get_vcs_manifest_path(installed_dir)
+            manifest_path = self.get_vcs_manifest_path(package_dir)
         else:
-            manifest_path = self.get_manifest_path(installed_dir)
+            manifest_path = self.get_manifest_path(package_dir)
 
         manifest = self.load_manifest(manifest_path)
         click.echo(
@@ -527,7 +531,7 @@ class BasePkgManager(PkgRepoMixin, PkgInstallerMixin):
                 click.echo("[%s]" % (click.style("Skip", fg="yellow")))
                 return
             click.echo("[%s]" % (click.style("VCS", fg="yellow")))
-            vcs = VCSClientFactory.newClient(installed_dir, manifest['url'])
+            vcs = VCSClientFactory.newClient(package_dir, manifest['url'])
             if not vcs.can_be_updated:
                 click.secho(
                     "Skip update because repository is fixed "

platformio/managers/platform.py

@@ -144,8 +144,8 @@ class PlatformFactory(object):
         else:
             if not requirements and "@" in name:
                 name, requirements = name.rsplit("@", 1)
-            platform_dir = PlatformManager().get_installed_dir(name,
+            platform_dir = PlatformManager().get_package_dir(name,
-                                                               requirements)
+                                                             requirements)
 
         if not platform_dir:
             raise exception.UnknownPlatform(name if not requirements else
@@ -167,30 +167,6 @@ class PlatformFactory(object):
 
 class PlatformPackagesMixin(object):
 
-    def get_installed_packages(self):
-        items = {}
-        installed = self.pm.get_installed()
-        for name, opts in self.packages.items():
-            manifest = None
-            reqspec = None
-            try:
-                reqspec = semantic_version.Spec(opts['version'])
-            except ValueError:
-                pass
-
-            for p in installed:
-                if p['name'] != name:
-                    continue
-                if reqspec and not reqspec.match(
-                        semantic_version.Version(p['version'])):
-                    continue
-                elif (not manifest or semantic_version.compare(
-                        p['version'], manifest['version']) == 1):
-                    manifest = p
-            if manifest:
-                items[name] = manifest
-        return items
-
     def install_packages(self,
                          with_packages=None,
                          without_packages=None,
@@ -217,6 +193,14 @@ class PlatformPackagesMixin(object):
 
         return True
 
+    def get_installed_packages(self):
+        items = {}
+        for name, opts in self.packages.items():
+            package = self.pm.get_package(name, opts['version'])
+            if package:
+                items[name] = package
+        return items
+
     def update_packages(self, only_check=False):
         for name in self.get_installed_packages():
             self.pm.update(name, self.packages[name]['version'], only_check)
@@ -228,6 +212,14 @@ class PlatformPackagesMixin(object):
                 return True
         return False
 
+    def get_package_dir(self, name):
+        return self.pm.get_package_dir(name,
+                                       self.packages[name].get("version"))
+
+    def get_package_version(self, name):
+        package = self.pm.get_package(name, self.packages[name].get("version"))
+        return package['version'] if package else None
+
 
 class PlatformRunMixin(object):
 
@@ -417,18 +409,6 @@ class PlatformBase(PlatformPackagesMixin, PlatformRunMixin):
     def board_config(self, id_):
         return self.get_boards(id_)
 
-    def get_package_dir(self, name):
-        packages = self.get_installed_packages()
-        if name not in packages:
-            return None
-        return packages[name]['__pkg_dir']
-
-    def get_package_version(self, name):
-        packages = self.get_installed_packages()
-        if name not in packages:
-            return None
-        return packages[name]['version']
-
     def get_package_type(self, name):
         return self.packages[name].get("type")