Merge pull request #3 from composer-version-manager/hook-cmd-template

Hook command scaffolding

Author: morgan-wowk

cvm/cli.py

@@ -3,19 +3,18 @@
 import sys
 from typing import Optional
 
-from cvm.helpers.cli import colored_fore
 from argparse_color_formatter import ColorRawTextHelpFormatter
 from colorama import Fore
 
 from cvm.commands.command import Command
-from cvm.commands.use_command import UseCommand
+from cvm.commands.hook_command import HookCommand
 from cvm.commands.install_command import InstallCommand
-from cvm.commands.scan_command import ScanCommand
 from cvm.commands.list_command import ListCommand
-
+from cvm.commands.scan_command import ScanCommand
+from cvm.commands.use_command import UseCommand
+from cvm.helpers.cli import colored_fore
 from cvm.services.cache_service import CacheService
 
-
 COMMAND_NAME = 'cvm'
 COMMAND_DESC = 'Composer Version Manager\n' + colored_fore(Fore.WHITE, 'Author: @game-of-morgan (Morgan Wowk)')
 COMMAND_EPILOG = 'https://github.com/game-of-morgan/cvm\n\nSupport this project by giving it a GitHub star ⭐️'
@@ -24,7 +23,8 @@
     UseCommand.NAME: UseCommand,
     InstallCommand.NAME: InstallCommand,
     ScanCommand.NAME: ScanCommand,
-    ListCommand.NAME: ListCommand
+    ListCommand.NAME: ListCommand,
+    HookCommand.NAME: HookCommand
 }
 
 

cvm/commands/hook_command.py

@@ -0,0 +1,29 @@
+from argparse import Action, Namespace
+
+from cvm.commands.command import Command
+from cvm.services.shell_service import ShellService
+
+
+class HookCommand(Command):
+    NAME = 'hook'
+    DESCRIPTION = 'Hook cvm to a shell.'
+
+    def exec(self, args: Namespace):
+        target = args.shell[0]
+
+        shell_service = ShellService()
+        shell = shell_service.get_shell_by_name(target)
+
+        hook = shell.get_hook()
+
+        print(hook)
+
+    @staticmethod
+    def define_signature(parser: Action):
+        hook_parser = parser.add_parser(HookCommand.NAME, help=HookCommand.DESCRIPTION)
+        hook_parser.add_argument(
+            'shell',
+            nargs=1,
+            help='Shell name to hook onto.',
+            metavar='{shell}'
+        )

cvm/commands/list_command.py

@@ -1,11 +1,9 @@
 from argparse import Action, Namespace
-from cvm.helpers.cli import green
-
 
 from cvm.commands.command import Command
+from cvm.services.cache_service import CacheService
 from cvm.services.composer_service import ComposerService
 from cvm.services.github_service import GitHubService
-from cvm.services.cache_service import CacheService
 
 
 class ListCommand(Command):
@@ -23,7 +21,6 @@ def exec(self, args: Namespace):
             else:
                 print(f"* {tag['name']}")
 
-
     @staticmethod
     def define_signature(parser: Action):
-        use_parser = parser.add_parser(ListCommand.NAME, help=ListCommand.DESCRIPTION)
+        parser.add_parser(ListCommand.NAME, help=ListCommand.DESCRIPTION)

cvm/commands/scan_command.py

@@ -1,16 +1,36 @@
 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
 
 
 class ScanCommand(Command):
     NAME = 'scan'
     DESCRIPTION = 'If present use .cvm_config from the current or specified directory.'
 
     def exec(self, args: Namespace):
-        print("Scan command executed.")
-        print(args)
+        if not ConfigService.exists():
+            return
+
+        data = ConfigService.read()
+        if not ConfigService.validate(data):
+            print("echo Invalid cvm config.")
+
+        github_service = GitHubService('composer', 'composer')
+        composer_service = ComposerService(github_service)
+
+        install_path = composer_service.use_version(data['requires'])
+
+        print(f"export PATH=:{install_path}:$PATH; echo Updated path.")
 
     @staticmethod
     def define_signature(parser: Action):
-        parser.add_parser(ScanCommand.NAME, help=ScanCommand.DESCRIPTION)
+        scan_parser = parser.add_parser(ScanCommand.NAME, help=ScanCommand.DESCRIPTION)
+        scan_parser.add_argument(
+            'shell',
+            nargs=1,
+            help='Shell name to cvm within.',
+            metavar='{shell}'
+        )

cvm/services/cache_service.py

@@ -1,8 +1,7 @@
-import os
 import logging
+import os
 import pathlib
 import sys
-from pathlib import Path
 
 
 class CacheService:
@@ -21,7 +20,7 @@ def boot_cache() -> None:
         CacheService.SETUP_DIR.mkdir(parents=True, exist_ok=True)
 
     @staticmethod
-    def get_cache_folder(folder: str) -> pathlib.Path:
+    def make_cache_folder(folder: str) -> pathlib.Path:
         fpath = CacheService.CACHE_DIR / folder
         fpath.mkdir(parents=True, exist_ok=True)
         return fpath

cvm/services/composer_service.py

@@ -1,11 +1,12 @@
-import sys
+import logging
 import pathlib
-import requests
 import subprocess
+import sys
+
+import requests
 
 from cvm.services.cache_service import CacheService
 from cvm.services.github_service import GitHubService
-import logging
 
 
 class ComposerService:
@@ -39,7 +40,7 @@ def cached_version_exists(tag_name: str) -> bool:
         :return: Bool
         '''
 
-        cache_path = CacheService.CACHE_DIR / tag_name
+        cache_path = CacheService.CACHE_DIR / tag_name / 'composer'
         return cache_path.exists()
 
     def _get_setup_path(self) -> pathlib.Path:
@@ -56,24 +57,25 @@ def _get_setup_path(self) -> pathlib.Path:
             setup_path.write_bytes(r.content)
         return setup_path
 
-    def install_version(self, tag_name: str) -> bool:
+    def install_version(self, tag_name: str, quiet=False) -> pathlib.Path:
         if not self.tag_exists(tag_name):
             logging.error("Tag {} does not exist.".format(tag_name))
             sys.exit(1)
 
         setup_path = self._get_setup_path()
-        cache_path = CacheService.get_cache_folder(tag_name)
+        cache_path = CacheService.make_cache_folder(tag_name)
+
+        if ComposerService.cached_version_exists(tag_name):
+            return 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)
-        print(result.stdout.decode('utf-8'))
-
-        return True
+        if not quiet:
+            print(result.stdout.decode('utf-8'))
 
-    def use_version(self, tag_name: str, check_exists: bool = True) -> bool:
-        if check_exists and not ComposerService.cached_version_exists(tag_name):
-            return False
+        return cache_path
 
-        # TODO: Use cached version if exists
+    def use_version(self, tag_name: str) -> str:
+        install_path = self.install_version(tag_name, quiet=True)
 
-        return True
+        return str(install_path)

cvm/services/config_service.py

@@ -0,0 +1,21 @@
+import json
+import pathlib
+
+
+class ConfigService:
+    FILENAME = '.cvm_config'
+    CONFIG_INPUT = pathlib.Path(FILENAME)
+
+    @staticmethod
+    def exists() -> bool:
+        return ConfigService.CONFIG_INPUT.exists()
+
+    @staticmethod
+    def read():
+        return json.load(ConfigService.CONFIG_INPUT.open('r'))
+
+    @staticmethod
+    def validate(data) -> bool:
+        if 'requires' not in data:
+            return False
+        return True

cvm/services/shell_service.py

@@ -0,0 +1,23 @@
+import logging
+import sys
+from typing import Optional
+
+from cvm.shells.shell import Shell
+from cvm.shells.shell_bash import ShellBash
+from cvm.shells.shell_zsh import ShellZsh
+
+SHELLS = {
+    ShellZsh.NAME: ShellZsh,
+    ShellBash.NAME: ShellBash
+}
+
+
+class ShellService:
+    @staticmethod
+    def get_shell_by_name(name: str) -> Optional[Shell]:
+        shell = SHELLS.get(name, None)
+        if shell is None:
+            logging.error("Shell {} not found".format(name))
+            sys.exit(1)
+
+        return shell()

cvm/shells/__init__.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+
+class Shell(ABC):
+
+    @staticmethod
+    @abstractmethod
+    def get_hook() -> str:
+        pass