Updated for tracking

slpkg/tracking.py

@@ -22,6 +22,9 @@ class Tracking(Configs):
         self.llc: str = self.ascii.lower_left_corner
         self.hl: str = self.ascii.horizontal_line
         self.vl: str = self.ascii.vertical_line
+        self.package_version: str = str()
+        self.package_dependency_version: str = str()
+        self.package_requires: tuple = tuple()
 
         self.is_binary: bool = self.utils.is_binary_repo(repository)
 
@@ -29,67 +32,75 @@ class Tracking(Configs):
             ['-p', '--pkg-version'], flags)
 
     def package(self) -> None:
-        print(f"The list below shows the packages '{', '.join([p for p in self.packages])}' with dependencies:\n")
+        self.view_the_title()
-        packages: tuple = tuple(self.utils.apply_package_pattern(self.data, self.packages))
 
-        for package in packages:
+        for package in self.packages:
             count_requires: int = 0
+
             pkg: str = f'{self.yellow}{package}{self.endc}'
             if self.option_for_pkg_version:
-                pkg = f'{self.yellow}{package} {self.choose_package_version(package)}{self.endc}'
+                self.set_package_version(package)
+                pkg = f'{self.yellow}{package} {self.package_version}{self.endc}'
 
-            requires: tuple = self.choose_requires(package)
+            self.set_package_requires(package)
+            self.view_the_main_package(pkg)
+            self.view_no_dependencies()
 
+            for n, req in enumerate(self.package_requires, start=1):
+                count_requires += 1
+
+                require: str = f'{self.cyan}{req}{self.endc}'
+                if self.option_for_pkg_version:
+                    self.set_package_dependency_version(req)
+                    require: str = (f'{self.cyan}{req}{self.endc}'
+                                    f'{self.package_dependency_version}')
+
+                self.view_require(n, require)
+            self.view_summary_of_tracking(count_requires, package)
+
+    def view_the_title(self):
+        print(f"The list below shows the packages '{', '.join([p for p in self.packages])}' with dependencies:\n")
+        self.packages: tuple = tuple(self.utils.apply_package_pattern(self.data, self.packages))
+
+    def view_the_main_package(self, pkg: str) -> None:
         print(pkg)
         print(f"{'':>1}{self.llc}{self.hl}", end='')
 
-            if not requires:
-                print(f"{'':>1}{self.cyan}No dependencies{self.endc}")
-
-            for n, req in enumerate(requires, start=1):
-                count_requires += 1
-                require: str = f'{self.cyan}{req}{self.endc}'
-                if self.option_for_pkg_version:
-                    require: str = (f'{self.cyan}{req}{self.endc}'
-                                    f'{self.choose_dependency_version(req)}')
-
-                self.print_require(n, require)
-            self.summary_of_tracking(count_requires, package)
-
-    def summary_of_tracking(self, count_requires: int, package: str):
-        print(f'\n{self.grey}{count_requires} dependencies for {package}{self.endc}\n')
-
     @staticmethod
-    def print_require(n: int, require: str) -> None:
+    def view_require(n: int, require: str) -> None:
         if n == 1:
             print(f"{'':>1}{require}")
         else:
             print(f"{'':>4}{require}")
 
-    def choose_dependency_version(self, require: str) -> str:
+    def view_no_dependencies(self):
+        if not self.package_requires:
+            print(f"{'':>1}{self.cyan}No dependencies{self.endc}")
+
+    def set_package_dependency_version(self, require: str):
         try:
             if self.is_binary:
                 # Not included here because of the dependency not included
                 # in the repository as package
-                version: str = f"{'':>1}(not included)"
+                self.package_dependency_version: str = f"{'':>1}(not included)"
                 if self.data.get(require):
-                    version: str = f"{'':>1}{self.yellow}{self.data[require][0]}{self.endc}"
+                    self.package_dependency_version: str = f"{'':>1}{self.yellow}{self.data[require][0]}{self.endc}"
             else:
-                version: str = f"{'':>1}{self.yellow}{self.data[require][2]}{self.endc}"
+                self.package_dependency_version: str = f"{'':>1}{self.yellow}{self.data[require][2]}{self.endc}"
         except KeyError:  # KeyError here because of the '%README%' as dependency
-            version: str = ''
+            self.package_dependency_version: str = ''
-        return version
 
-    def choose_package_version(self, package: str) -> str:
+    def set_package_version(self, package: str) -> None:
         if self.is_binary:
-            version: str = self.data[package][0]
+            self.package_version: str = self.data[package][0]
         else:
-            version: str = self.data[package][2]
+            self.package_version: str = self.data[package][2]
-        return version
 
-    def choose_requires(self, package: str) -> tuple:
+    def set_package_requires(self, package: str):
         if self.is_binary:
-            requires: tuple = self.data[package][6].split()
+            self.package_requires: tuple = self.data[package][6].split()
         else:
-            requires: tuple = self.data[package][7].split()
+            self.package_requires: tuple = self.data[package][7].split()
-        return requires
+
+    def view_summary_of_tracking(self, count_requires: int, package: str):
+        print(f'\n{self.grey}{count_requires} dependencies for {package}{self.endc}\n')