Merge branch 'master' into dependabot/pip/mypy-1.4.1

Author: eadwinCode

.github/workflows/test_full.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
+        python-version: ['3.8', '3.9', '3.10', '3.11']
 
     steps:
       - uses: actions/checkout@v3
@@ -39,9 +39,7 @@ jobs:
         run: flit install --symlink
       - name: Black
         run: black --check ellar_cli tests
-      - name: isort
-        run: isort --check ellar_cli tests
-      - name: Flake8
-        run: flake8 ellar_cli tests
+      - name: Ruff linting check
+        run: ruff check ellar_cli tests
       - name: mypy
         run: mypy ellar_cli

Makefile

@@ -19,14 +19,12 @@ install-full: ## Install dependencies
 
 lint: ## Run code linters
 	black --check ellar_cli tests
-	isort --check ellar_cli tests
-	autoflake --remove-unused-variables --remove-unused-variables -r ellar_cli tests
-	flake8 ellar_cli tests
+	ruff check ellar_cli tests
 	mypy ellar_cli
 
 fmt format: ## Run code formatters
 	black ellar_cli tests
-	isort ellar_cli tests
+	ruff check --fix ellar_cli tests
 
 test: ## Run tests
 	pytest tests

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="#" target="blank"><img src="docs/img/EllarLogoIconOnly.png" width="200" alt="Ellar Logo" /></a>
+  <a href="#" target="blank"><img src="https://eadwincode.github.io/ellar/img/EllarLogoB.png" width="200" alt="Ellar Logo" /></a>
 </p>
 
 <p align="center"> Ellar CLI Tool for Scaffolding Ellar Projects and Modules and also running Ellar Commands</p>

ellar_cli/file_scaffolding.py

@@ -1,13 +1,12 @@
 import os
 import typing as t
 from abc import abstractmethod
+from pathlib import Path
 
 from jinja2 import Environment
 
 from ellar_cli.schema import EllarScaffoldList, EllarScaffoldSchema
 
-from .service import EllarCLIService
-
 __all__ = ["FileTemplateScaffold"]
 
 
@@ -26,17 +25,20 @@ def __init__(
         working_project_name: str,
         working_directory: str,
         scaffold_ellar_template_root_path: str,
-        ellar_cli_service: t.Optional[EllarCLIService] = None,
+        specified_directory: t.Optional[str] = None,
     ) -> None:
+        self._specified_directory = specified_directory
         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._ctx = ProjectScaffoldContext(Environment())
         self._scaffold_ellar_template_root_path = scaffold_ellar_template_root_path
-        self.ellar_cli_service = ellar_cli_service
-        self.validate_project_name()
+
+        if self._specified_directory:
+            _cwd_path = Path(self._get_working_cwd(working_directory))
+            self._working_project_name = _cwd_path.name
+            self._working_directory = str(_cwd_path.parent)
+        else:
+            self._working_directory = working_directory
+            self._working_project_name = working_project_name
 
     def get_scaffolding_context(self, working_project_name: str) -> t.Dict:
         return {}
@@ -61,6 +63,8 @@ def create_file(self, base_path: str, file_name: str, content: t.Any) -> None:
             fw.writelines(refined_content)
 
     def scaffold(self) -> None:
+        self.validate_project_name()
+        self._ctx = self.get_templating_context()
         self.on_scaffold_started()
         for file in self._schema.files:
             self.create_directory(
@@ -92,9 +96,9 @@ def create_directory(
         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 []:
+            for _file in file.files:
                 self.create_directory(
-                    file=file,
+                    file=_file,
                     working_directory=new_scaffold_dir,
                     scaffold_ellar_template_path=scaffold_template_path,
                 )
@@ -108,3 +112,22 @@ def create_directory(
     def validate_project_name(self) -> None:
         # Check it's a valid directory name.
         pass
+
+    def _get_working_cwd(self, working_directory: str) -> str:
+        if self._specified_directory:
+            return self._handle_directory_change(working_directory)
+        return working_directory
+
+    def _handle_directory_change(self, working_directory: str) -> str:
+        if self._specified_directory == ".":
+            return working_directory
+
+        _specified_directory = (
+            self._specified_directory.lower()  # type:ignore[union-attr]
+        )
+        return os.path.join(working_directory, _specified_directory)
+
+    def get_templating_context(self) -> ProjectScaffoldContext:
+        return ProjectScaffoldContext(
+            Environment(), **self.get_scaffolding_context(self._working_project_name)
+        )

ellar_cli/main.py

@@ -61,7 +61,7 @@ def build_typers() -> t.Any:
 
     if meta_ and meta_.has_meta:
         module_configs = AppFactory.get_all_modules(
-            ModuleSetup(meta_.import_root_module())  # type:ignore
+            ModuleSetup(meta_.import_root_module())
         )
         reflector = Reflector()
 

ellar_cli/manage_commands/create_module.py

@@ -2,16 +2,16 @@
 import sys
 import typing as t
 from importlib import import_module
+from pathlib import Path
 
 import typer
 from ellar.common.helper.module_loading import module_dir
 
 from ellar_cli import scaffolding
-from ellar_cli.constants import ELLAR_META
 from ellar_cli.schema import EllarScaffoldSchema
 
 from ..file_scaffolding import FileTemplateScaffold
-from ..service import EllarCLIException, EllarCLIService
+from ..service import EllarCLIException
 
 __all__ = ["create_module"]
 
@@ -21,6 +21,19 @@
 
 
 class ModuleTemplateScaffold(FileTemplateScaffold):
+    def __init__(
+        self, working_project_name: str, working_directory: str, **kwargs: t.Any
+    ) -> None:
+        super().__init__(
+            working_project_name=working_project_name,
+            working_directory=working_directory,
+            **kwargs,
+        )
+        if self._specified_directory:
+            _cwd_path = Path(self._get_working_cwd(working_directory))
+            self._working_project_name = working_project_name
+            self._working_directory = str(_cwd_path)
+
     def on_scaffold_completed(self) -> None:
         print(f"{self._working_project_name} module completely scaffolded")
 
@@ -55,28 +68,26 @@ def validate_project_name(self) -> None:
                 sys.path.remove(self._working_directory)
 
     def get_scaffolding_context(self, working_project_name: str) -> t.Dict:
-        template_context = dict(module_name=working_project_name)
+        template_context = {"module_name": working_project_name}
         return template_context
 
 
-def create_module(ctx: typer.Context, module_name: str):
+def create_module(
+    module_name: str,
+    directory: t.Optional[str] = typer.Argument(
+        None,
+        help="The name of a new directory to scaffold the module into.",
+        show_default=False,
+    ),
+):
     """- Scaffolds Ellar Application Module -"""
 
-    ellar_project_meta = t.cast(t.Optional[EllarCLIService], ctx.meta.get(ELLAR_META))
-    if not ellar_project_meta:
-        raise EllarCLIException("No pyproject.toml file found.")
-
-    if not ellar_project_meta.has_meta:
-        raise EllarCLIException(
-            "No available project found. please create ellar project with `ellar create-project 'project-name'`"
-        )
-
     schema = EllarScaffoldSchema.parse_file(module_template_json)
     project_template_scaffold = ModuleTemplateScaffold(
         schema=schema,
-        working_directory=ellar_project_meta.get_apps_module_path(),
+        working_directory=os.getcwd(),
         scaffold_ellar_template_root_path=root_scaffold_template_path,
-        ellar_cli_service=ellar_project_meta,
+        specified_directory=directory,
         working_project_name=module_name.lower(),
     )
     project_template_scaffold.scaffold()

ellar_cli/manage_commands/create_project.py

@@ -22,10 +22,15 @@
 
 
 class ProjectTemplateScaffold(FileTemplateScaffold):
+    def __init__(self, ellar_cli_service: EllarCLIService, **kwargs: t.Any) -> None:
+        super().__init__(**kwargs)
+        self.ellar_cli_service = ellar_cli_service
+
     def get_scaffolding_context(self, working_project_name: str) -> t.Dict:
-        template_context = dict(
-            project_name=working_project_name, secret_key=f"ellar_{uuid.uuid4()}"
-        )
+        template_context = {
+            "project_name": working_project_name,
+            "secret_key": f"ellar_{uuid.uuid4()}",
+        }
         return template_context
 
     def validate_project_name(self) -> None:

ellar_cli/manage_commands/new.py

@@ -24,8 +24,21 @@ class NewTemplateScaffold(FileTemplateScaffold):
     unwanted_chars = "".join(["-", ";", "!", "*", ":", " "])
 
     def __init__(self, project_name: str = None, **kwargs: t.Any) -> None:
+        super(NewTemplateScaffold, self).__init__(
+            working_project_name=project_name, **kwargs
+        )
         self._project_name = project_name
-        super(NewTemplateScaffold, self).__init__(**kwargs)
+
+    def create_file(self, base_path: str, file_name: str, content: t.Any) -> None:
+        _path = os.path.join(base_path, file_name.replace(".ellar", ".py"))
+        if os.path.exists(_path):
+            content = self.read_file_content(path=_path)
+
+        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 on_scaffold_completed(self) -> None:
         popen_res = subprocess.run(
@@ -36,9 +49,18 @@ def on_scaffold_completed(self) -> None:
         )
         if popen_res.returncode == 0:
             project_working_project_name = self.get_project_name()
+
+            log_1 = f"- cd {self._working_project_name}"
+            if self._specified_directory:
+                log_1 = (
+                    f"- cd {self._specified_directory.lower()}"
+                    if self._specified_directory != "."
+                    else ""
+                )
+
             print(
-                f"`{self._working_project_name}` project created successfully.\n"
-                f"- cd {self._working_project_name}"
+                f"`{project_working_project_name}` project created successfully.\n"
+                f"{log_1}"
             )
             print("To start your server, run the command below")
             print(
@@ -47,13 +69,37 @@ def on_scaffold_completed(self) -> None:
         else:
             print(popen_res.stderr.decode("utf8"))
 
+    def is_directory_empty(self) -> bool:
+        """
+        Check if the given directory is empty.
+        """
+        # Get the list of files and directories in the directory
+        working_project_dir = os.path.join(
+            self._working_directory, self._working_project_name
+        )
+        if os.path.isdir(working_project_dir):
+            items = os.listdir(working_project_dir)
+            exclude = ["poetry.lock", "pyproject.toml"]
+            items = [item for item in items if item not in exclude]
+            return len(items) == 0
+        return True
+
     def validate_project_name(self) -> None:
         if os.path.exists(self._working_project_name):
             message = "A folder with same name exist '{name}' ".format(
                 name=self._working_project_name
             )
             raise EllarCLIException(message)
 
+        if not self.is_directory_empty():
+            working_project_dir = os.path.join(
+                self._working_directory, self._working_project_name
+            )
+            message = (
+                f"Scaffolding Project Directory is not empty. - {working_project_dir}"
+            )
+            raise EllarCLIException(message)
+
         project_working_project_name = self.get_project_name()
         if not project_working_project_name.isidentifier():
             message = (
@@ -64,9 +110,10 @@ def validate_project_name(self) -> None:
             raise EllarCLIException(message)
 
     def get_scaffolding_context(self, working_project_name: str) -> t.Dict:
-        template_context = dict(
-            folder_name=working_project_name, project_name=self.get_project_name()
-        )
+        template_context = {
+            "folder_name": working_project_name,
+            "project_name": self.get_project_name(),
+        }
         return template_context
 
     def get_project_name(self) -> str:
@@ -78,10 +125,14 @@ def get_project_cwd(self) -> str:
 
 
 def new_command(
-    folder_name: str,
-    project_name: t.Optional[str] = typer.Option(
+    project_name: str = typer.Argument(
+        None,
+        help="Project Module Name. Defaults to `project-name` if not set",
+        show_default=False,
+    ),
+    directory: t.Optional[str] = typer.Argument(
         None,
-        help="Project Module Name. Defaults to `folder-name` if not set",
+        help="The name of a new directory to scaffold the project into. Scaffolding into an existing directory is only allowed if the directory is empty",
         show_default=False,
     ),
 ):
@@ -91,7 +142,7 @@ def new_command(
         schema=schema,
         working_directory=os.getcwd(),
         scaffold_ellar_template_root_path=root_scaffold_template_path,
-        working_project_name=folder_name.lower(),
         project_name=project_name,
+        specified_directory=directory,
     )
     init_template_scaffold.scaffold()