Merge pull request #4 from composer-version-manager/application-service

Update PATH when version changes

Author: ubaniak

cvm/cli.py

@@ -8,7 +8,6 @@
 
 from cvm.commands.command import Command
 from cvm.commands.hook_command import HookCommand
-from cvm.commands.install_command import InstallCommand
 from cvm.commands.list_command import ListCommand
 from cvm.commands.scan_command import ScanCommand
 from cvm.commands.use_command import UseCommand
@@ -21,7 +20,6 @@
 
 COMMANDS = {
     UseCommand.NAME: UseCommand,
-    InstallCommand.NAME: InstallCommand,
     ScanCommand.NAME: ScanCommand,
     ListCommand.NAME: ListCommand,
     HookCommand.NAME: HookCommand
@@ -30,11 +28,8 @@
 
 def get_command_by_name(name: str) -> Optional[Command]:
     command = COMMANDS.get(name, None)
-    if command is None:
-        logging.error("Command {} not found".format(name))
-        sys.exit(1)
 
-    return command()
+    return command
 
 
 def main():
@@ -55,4 +50,8 @@ def main():
     args = parser.parse_args()
 
     command = get_command_by_name(args.command)
-    command.exec(args)
+    if command is None:
+        parser.print_help(sys.stdout)
+        return
+
+    command().exec(args)

cvm/commands/install_command.py

@@ -4,26 +4,47 @@
 from cvm.services.composer_service import ComposerService
 from cvm.services.config_service import ConfigService
 from cvm.services.github_service import GitHubService
+from cvm.services.application_service import ApplicationService
+from cvm.helpers.cli import warning
+from colorama import Fore
 
 
 class ScanCommand(Command):
     NAME = 'scan'
     DESCRIPTION = 'If present use .cvm_config from the current or specified directory.'
 
     def exec(self, args: Namespace):
-        if not ConfigService.exists():
+        version = None
+
+        if ConfigService.exists():
+            version = self._check_local()
+        else:
+            version = self._check_global()
+
+        if version is None:
             return
 
+        github_service = GitHubService('composer', 'composer')
+        composer_service = ComposerService(github_service)
+
+        updated_path = composer_service.use_version(version, False)
+
+        print(f"export PATH=\"{updated_path}\"; echo Updated path.;")
+
+    def _check_local(self):
         data = ConfigService.read()
         if not ConfigService.validate(data):
-            print("echo Invalid cvm config.")
+            msg = warning(".cvm_config format in current directory is invalid.")
+            print(f"echo \"{msg}\"")
 
-        github_service = GitHubService('composer', 'composer')
-        composer_service = ComposerService(github_service)
+            return None
 
-        install_path = composer_service.use_version(data['requires'])
+        return data['requires']
 
-        print(f"export PATH=:{install_path}:$PATH; echo Updated path.")
+    def _check_global(self):
+        application_service = ApplicationService()
+        
+        return application_service.get('global')
 
     @staticmethod
     def define_signature(parser: Action):

cvm/commands/scan_command.py

@@ -1,25 +1,28 @@
+import os
+import subprocess
 from argparse import Action, Namespace
 
 from cvm.commands.command import Command
 from cvm.services.composer_service import ComposerService
+from cvm.services.config_service import ConfigService
 from cvm.services.github_service import GitHubService
+from cvm.helpers.cli import info
+from colorama import Fore
 
 
 class UseCommand(Command):
     NAME = 'use'
-    DESCRIPTION = 'Use a specific version of Composer; Defaulting to the latest stable major version when there is a ' \
-                  'lack of specificity (ie. 2). '
+    DESCRIPTION = 'Globally use a specific composer version.'
 
     def exec(self, args: Namespace):
-        desired_version = args.version[0]
+        version = args.version[0]
 
         github_service = GitHubService('composer', 'composer')
         composer_service = ComposerService(github_service)
 
-        existed = composer_service.use_version(desired_version)
-        if not existed:
-            composer_service.install_version(desired_version)
-            composer_service.use_version(desired_version, False)
+        composer_service.use_version(version, True)
+
+        print(f"Global composer version updated to {version}.")
 
     @staticmethod
     def define_signature(parser: Action):

cvm/commands/use_command.py

@@ -4,3 +4,9 @@
 
 def colored_fore(color: AnsiFore, text: str, default: str = Fore.LIGHTWHITE_EX) -> str:
     return color + text + default
+
+def warning(text: str, default: str = Fore.LIGHTWHITE_EX) -> str:
+    return colored_fore(Fore.LIGHTRED_EX, text)
+
+def info(text: str, default: str = Fore.LIGHTWHITE_EX) -> str:
+    return colored_fore(Fore.LIGHTYELLOW_EX, text)

cvm/helpers/cli.py

@@ -0,0 +1,69 @@
+import json
+import logging
+import os
+import subprocess
+import re
+import pathlib
+import sys
+from enum import Enum
+from typing import Any, Optional
+
+
+class ComposerSource(Enum):
+    Empty = ''
+    Global = 'global'
+    Config = 'config'
+
+class ApplicationService:
+    APP_DIR = pathlib.Path.home() / '.cvm'
+    APP_FILE_PATH = APP_DIR / 'config.json'
+
+    def __init__(self):
+        ApplicationService.APP_DIR.mkdir(parents=True, exist_ok=True)
+        ApplicationService.APP_FILE_PATH.touch(exist_ok=True)
+        self._parse()
+
+    def get_updated_path(self, bin_path: str) -> str:
+        envPath = self._get_env_path()
+        clean_path = self._clean_env_path(envPath)
+        updated_path = f"{bin_path}:{clean_path}"
+        
+        return updated_path
+
+    def _clean_env_path(self, envPath: str) -> str:
+        return re.sub(r'\/(\b[^:]+)\/.cvm\/cache\/.+?(:|$)', '', envPath)
+
+    def _get_env_path(self) -> str:
+        return subprocess.check_output("echo $PATH", shell=True).decode('ascii')
+
+    def _parse(self):
+        try:
+            self._app = json.load(ApplicationService.APP_FILE_PATH.open('r'))
+        except:
+            self._app = {}
+
+        if not self._app:
+            self._app = {
+                'global': None,
+                'current': None,
+                'source': str(ComposerSource.Empty),
+            }
+            self._write()
+
+    def _write(self):
+        ApplicationService.APP_FILE_PATH.write_text(json.dumps(self._app))
+
+    def app(self) -> dict:
+        return self._app
+
+    def get(self, key: str) -> Any:
+        return self._app.get(key)
+
+    def set(self, key: str, value: Any):
+        if type(value) is ComposerSource:
+            value = str(value)
+
+        self._app[key] = value
+
+    def save(self):
+        self._write()

cvm/services/application_service.py

@@ -7,6 +7,7 @@
 
 from cvm.services.cache_service import CacheService
 from cvm.services.github_service import GitHubService
+from cvm.services.application_service import ApplicationService, ComposerSource
 
 
 class ComposerService:
@@ -57,7 +58,7 @@ def _get_setup_path(self) -> pathlib.Path:
             setup_path.write_bytes(r.content)
         return setup_path
 
-    def install_version(self, tag_name: str, quiet=False) -> pathlib.Path:
+    def install_version(self, tag_name: str, quiet=False) -> str:
         if not self.tag_exists(tag_name):
             logging.error("Tag {} does not exist.".format(tag_name))
             sys.exit(1)
@@ -66,16 +67,28 @@ def install_version(self, tag_name: str, quiet=False) -> pathlib.Path:
         cache_path = CacheService.make_cache_folder(tag_name)
 
         if ComposerService.cached_version_exists(tag_name):
-            return cache_path
+            return str(cache_path)
 
         cmd = ['php', str(setup_path), f'--install-dir={str(cache_path)}', '--filename=composer', f'--version={tag_name}']
         result = subprocess.run(cmd, stdout=subprocess.PIPE, check=True)
         if not quiet:
             print(result.stdout.decode('utf-8'))
 
-        return cache_path
+        return str(cache_path)
 
-    def use_version(self, tag_name: str) -> str:
-        install_path = self.install_version(tag_name, quiet=True)
+    def use_version(self, tag_name: str, is_global: bool) -> str:
+        bin_path = self.install_version(tag_name, quiet=True)
 
-        return str(install_path)
+        application_service = ApplicationService()
+        application_service.set('current', tag_name)
+
+        if is_global:
+            application_service.set('global', tag_name)
+            application_service.set('source', ComposerSource.Global.value)
+        else:
+            application_service.set('source', ComposerSource.Config.value)
+
+        application_service.save()
+        updated_path = application_service.get_updated_path(bin_path)
+
+        return updated_path