Merge pull request #20 from eadwinCode/cli_commands_and_project_scaffold_init

WIP: CLI Commands And Basic Project Scaffolding

Author: eadwinCode

.github/workflows/test.yml

@@ -2,8 +2,8 @@ name: Test
 
 on:
   push:
-    branches:
-      - master
+  pull_request:
+    types: [assigned, opened, synchronize, reopened]
 
 jobs:
   test_coverage:

.github/workflows/test_full.yml

@@ -32,7 +32,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v4
         with:
-          python-version: 3.9
+          python-version: 3.8
       - name: Install Flit
         run: pip install flit
       - name: Install Dependencies

.pre-commit-config.yaml

@@ -9,11 +9,18 @@ repos:
   - id: yesqa
 - repo: local
   hooks:
-    - id: code_linting
+    - id: code_formatting
       args: []
+      name: Code Formatting
+      entry: "make fmt"
+      types: [python]
+      language_version: python3.6
+      language: python
+    - id: code_linting
+      args: [ ]
       name: Code Linting
       entry: "make lint"
-      types: [python]
+      types: [ python ]
       language_version: python3.6
       language: python
 - repo: https://github.com/pre-commit/pre-commit-hooks

Makefile

@@ -13,6 +13,10 @@ clean: ## Removing cached python compiled files
 install: ## Install dependencies
 	flit install --deps develop --symlink
 
+install-full: ## Install dependencies
+	make install
+	pre-commit install -f
+
 lint: ## Run code linters
 	black --check ellar tests
 	isort --check ellar tests
@@ -33,3 +37,9 @@ test-cov: ## Run tests with coverage
 doc-deploy: ## Run Deploy Documentation
 	make clean
 	mkdocs gh-deploy --force
+
+
+pre-commit-lint: ## Runs Requires commands during pre-commit
+	make clean
+	make fmt
+	make lint

ellar/__init__.py

@@ -1,3 +1,3 @@
-"""Ellar is python web framework for building fast, efficient and scalable server-side applications."""
+"""Ellar - Python ASGI web framework for building fast, efficient and scalable RESTAPIs and server-side application."""
 
 __version__ = "0.1.4"

ellar/__main__.py

@@ -1,3 +1,4 @@
-from ellar.cli import main
+if __name__ == "__main__":
+    from ellar.cli import main
 
-main()
+    main()

ellar/cli.py

@@ -0,0 +1,33 @@
+import os
+import sys
+import typing as t
+
+from typer import echo
+
+from ._main import _typer, build_typers
+
+__all__ = ["main"]
+
+
+def register_commands(*typer_commands: t.Any) -> None:
+    for typer_command in typer_commands:
+        _typer.add_typer(typer_command)
+
+
+@_typer.command()
+def say_hi(name: str):
+    echo(f"Welcome {name}, to Ellar CLI, python web framework")
+
+
+# register all EllarTyper(s) to root typer
+# register_commands(*other_commands)
+
+
+def main():
+    sys.path.append(os.getcwd())
+    build_typers()
+    _typer(prog_name="Ellar, Python Web framework")
+
+
+if __name__ == "__main__":
+    main()

ellar/cli/__init__.py

@@ -0,0 +1,74 @@
+import getopt
+import sys
+import typing as t
+
+import typer
+from typer import Typer
+from typer.models import CommandInfo
+
+from ellar.commands import EllarTyper
+from ellar.constants import CALLABLE_COMMAND_INFO, ELLAR_META, MODULE_METADATA
+from ellar.core.factory import AppFactory
+from ellar.services import Reflector
+
+from .manage_commands import create_module, create_project, runserver
+from .service import EllarCLIService
+
+__all__ = ["build_typers", "_typer", "typer_callback"]
+
+_typer = Typer(name="ellar")
+
+_typer.command()(runserver)
+_typer.command(name="create-project")(create_project)
+_typer.command(name="create-module")(create_module)
+
+
+@_typer.callback()
+def typer_callback(
+    ctx: typer.Context,
+    project: t.Optional[str] = typer.Option(
+        None,
+        "-p",
+        "--project",
+        show_default=True,
+        exists=True,
+        help="Run Specific Command on a specific project",
+    ),
+) -> None:
+    meta_: EllarCLIService = EllarCLIService.import_project_meta(project)
+    ctx.meta[ELLAR_META] = meta_
+
+
+def build_typers() -> None:
+    try:
+        options, args = getopt.getopt(
+            sys.argv[1:],
+            "p:",
+            [
+                "project=",
+            ],
+        )
+        app_name: t.Optional[str] = None
+
+        for k, v in options:
+            if k in ["-p", "--project"] and v:
+                app_name = v
+    except Exception:
+        raise typer.Abort()
+
+    meta_: EllarCLIService = EllarCLIService.import_project_meta(app_name)
+
+    if meta_ and meta_.has_meta:
+        modules = AppFactory.get_all_modules(meta_.import_root_module())
+        reflector = Reflector()
+
+        for module in modules:
+            typers_commands = reflector.get(MODULE_METADATA.COMMANDS, module) or []
+            for typer_command in typers_commands:
+                if isinstance(typer_command, EllarTyper):
+                    _typer.add_typer(typer_command)
+                elif hasattr(typer_command, CALLABLE_COMMAND_INFO):
+                    command_info: CommandInfo = typer_command.__dict__[
+                        CALLABLE_COMMAND_INFO
+                    ]
+                    _typer.registered_commands.append(command_info)

ellar/cli/_main.py

@@ -0,0 +1,107 @@
+import os
+import typing as t
+from abc import abstractmethod
+
+from jinja2 import Environment
+
+from ellar.core.schema import EllarScaffoldList, EllarScaffoldSchema
+
+from .service import EllarCLIService
+
+__all__ = ["FileTemplateScaffold"]
+
+
+class ProjectScaffoldContext(dict):
+    def __init__(self, environment: Environment, **kwargs):
+        super().__init__(kwargs)
+        self.environment = environment
+        self.environment.globals.update(kwargs)
+
+
+class FileTemplateScaffold:
+    def __init__(
+        self,
+        *,
+        schema: EllarScaffoldSchema,
+        working_project_name: str,
+        working_directory: str,
+        scaffold_ellar_template_root_path: str,
+        ellar_cli_service: EllarCLIService,
+    ):
+        self._schema = schema
+        self._working_project_name = working_project_name
+        self._ctx = ProjectScaffoldContext(
+            Environment(), **self.get_scaffolding_context(working_project_name)
+        )
+        self._working_directory = working_directory
+        self._scaffold_ellar_template_root_path = scaffold_ellar_template_root_path
+        self.ellar_cli_service = ellar_cli_service
+        self.validate_project_name()
+
+    def get_scaffolding_context(self, working_project_name: str) -> t.Dict:
+        return {}
+
+    @classmethod
+    def read_file_content(cls, path: str) -> str:
+        with open(path, mode="r") as fp:
+            return fp.read()
+
+    def create_root_path(self) -> str:
+        root_dir = os.path.join(
+            self._working_directory, self._working_project_name.lower()
+        )
+        os.mkdir(root_dir)
+        return root_dir
+
+    def create_file(self, base_path: str, file_name: str, content: t.Any) -> None:
+        with open(
+            os.path.join(base_path, file_name.replace("ellar", "py")), mode="w"
+        ) as fw:
+            refined_content = self._ctx.environment.from_string(content).render()
+            fw.writelines(refined_content)
+
+    def scaffold(self) -> None:
+        self.on_scaffold_started()
+        for file in self._schema.files:
+            self.create_directory(
+                file,
+                scaffold_ellar_template_path=self._scaffold_ellar_template_root_path,
+                working_directory=self._working_directory,
+            )
+        self.on_scaffold_completed()
+
+    def on_scaffold_completed(self) -> None:
+        pass
+
+    def on_scaffold_started(self) -> None:
+        for context in self._schema.context:
+            assert self._ctx[context], f"{context} template context is missing."
+
+    def create_directory(
+        self, file: EllarScaffoldList, scaffold_ellar_template_path, working_directory
+    ) -> None:
+        name = file.name
+        if name in self._ctx:
+            name = self._ctx.get(file.name, file.name)
+
+        scaffold_template_path = os.path.join(scaffold_ellar_template_path, file.name)
+
+        if file.is_directory:
+            new_scaffold_dir = os.path.join(working_directory, name)
+            os.makedirs(new_scaffold_dir, exist_ok=True)
+            for file in file.files or []:
+                self.create_directory(
+                    file=file,
+                    working_directory=new_scaffold_dir,
+                    scaffold_ellar_template_path=scaffold_template_path,
+                )
+        else:
+            content = self.read_file_content(scaffold_template_path)
+            self.create_file(
+                base_path=working_directory, file_name=name, content=content
+            )
+
+    @abstractmethod
+    def validate_project_name(self) -> None:
+        # Check it's a valid directory name.
+        pass