feat: add template voldemort closes #4 (#15)

* feat: add template voldemort

Define rules that ensure that a specific name isn't used in the code.

Create rules for:

* function names
* function arguments
* class names
* variable declarations
* variable assignments

version 0.4.0

Author: reka

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2023-01-05
+
+### Added
+
+* "voldemort" rule template and command: names to avoid in your code
+
 ## [0.3.3] - 2022-12-21
 
 ### Added

README.md

@@ -18,8 +18,9 @@ sourcery-rules <TEMPLATE-NAME> create
 
 Supported templates:
 
-* dependencies
-* naming (coming soon)
+* [dependencies](#create-dependencies-rules)
+* [naming / voldemort](#create-voldemort-rules): avoid some names
+* naming / name vs type mismatch (coming soon)
 
 For example:
 
@@ -89,6 +90,37 @@ This [blog post](https://sourcery.ai/blog/dependency-rules/) shows a 3-step meth
 2. Phrase some rules in a human language based on the diagram: Which package should depend on which?
 3. Translate the rules into code with Sourcery Rules Generator.
 
+## Create Voldemort Rules
+
+With a "voldemort" template, you can create rules that ensure that a specific name isn't used in your code.
+
+For example:
+
+* The word `annual` shouldn't be used, because the preferred term is `yearly`.
+* The word `util` shouldn't be used, because it's overly general.
+
+You can create a "voldemort" rule with the command:
+
+```
+sourcery-rules voldemort create
+```
+
+![screenshot sourcery-rules voldemort create](https://raw.githubusercontent.com/sourcery-ai/sourcery-rules-generator/main/voldemort_create.png)
+
+You'll be prompted to provide:
+
+* the name that you want to avoid
+
+=>
+
+5 rules will be generated:
+
+* function names
+* function arguments
+* class names
+* variable declarations
+* variable assignments
+
 ## Using the Generated Rules
 
 The generated rules can be used by Sourcery to review your project.

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sourcery-rules-generator"
-version = "0.3.3"
+version = "0.4.0"
 description = "Generate architecture rules for Python projects."
 license = "MIT"
 authors = ["reka <reka@sourcery.ai>"]

sourcery_rules_generator/__init__.py

@@ -1 +1 @@
-__version__ = "0.3.3"
+__version__ = "0.4.0"

sourcery_rules_generator/cli/cli.py

@@ -4,11 +4,12 @@
 
 from rich.console import Console
 
-from sourcery_rules_generator.cli import dependencies_cli
+from sourcery_rules_generator.cli import dependencies_cli, voldemort_cli
 from sourcery_rules_generator import __version__
 
 app = typer.Typer(rich_markup_mode="markdown")
 app.add_typer(dependencies_cli.app, name="dependencies")
+app.add_typer(voldemort_cli.app, name="voldemort")
 
 
 @app.callback(invoke_without_command=True)

sourcery_rules_generator/cli/voldemort_cli.py

@@ -0,0 +1,84 @@
+#! /usr/bin/env python3
+
+import sys
+import typer
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.prompt import Prompt
+from rich.syntax import Syntax
+
+from sourcery_rules_generator import voldemort
+
+app = typer.Typer(rich_markup_mode="markdown")
+
+
+DESCRIPTION_MARKDOWN = """
+# "Voldemort" Template
+
+With the "Voldemort" template,  
+you can generate rules that ensure that a specific word isn't used in your codebase.
+
+For example:
+
+* The word `annual` shouldn't be used, because the preferred term is `yearly`.
+* The word `util` shouldn't be used, because it's overly general.
+
+## Parameters for the "Voldemort" Template
+
+1. The word that should be avoided. Required.
+"""
+
+
+@app.command()
+def create(
+    avoided_name_option: str = typer.Option(
+        None,
+        "--avoided-name",
+        help="The name that should be avoided.",
+    ),
+    interactive_flag: bool = typer.Option(
+        True,
+        "--interactive/--no-interactive",
+        "--input/--no-input",
+        help="Switch whether interactive prompts are shown. Use `--no-input` when you call this command from scripts.",
+    ),
+    plain: bool = typer.Option(False, help="Print only plain text."),
+    quiet: bool = typer.Option(
+        False,
+        "--quiet",
+        "-q",
+        help='Display less info about the "Voldemort" template.',
+    ),
+):
+    """Create a new Sourcery Voldemort rule."""
+    interactive = sys.stdin.isatty() and interactive_flag
+    stderr_console = Console(stderr=True)
+    if interactive and not quiet:
+        stderr_console.print(Markdown(DESCRIPTION_MARKDOWN))
+        stderr_console.rule()
+
+    if interactive:
+        stderr_console.print(Markdown('## Parameters for the "Voldemort" Template'))
+
+    name_to_avoid = (
+        avoided_name_option
+        or interactive
+        and Prompt.ask("The name to avoid: (required)", console=stderr_console)
+    )
+    if not name_to_avoid:
+        _raise_error("No name to avoid provided. Can't create voldemort rule.")
+
+    result = voldemort.create_yaml_rules(name_to_avoid)
+
+    stderr_console.rule()
+    stderr_console.print(Markdown("## Generated YAML Rules"))
+    if plain:
+        Console().print(result)
+    else:
+        Console().print(Syntax(result, "YAML"))
+
+
+def _raise_error(error_msg: str, code: int = 1) -> None:
+    stderr_console = Console(stderr=True, style="bold red")
+    stderr_console.print(error_msg)
+    raise typer.Exit(code=code)

sourcery_rules_generator/voldemort.py

@@ -0,0 +1,73 @@
+from typing import Optional
+
+from sourcery_rules_generator import yaml_converter
+from sourcery_rules_generator.models import SourceryCustomRule, PathsConfig
+
+
+def create_yaml_rules(name_to_avoid: str):
+
+    custom_rules = create_sourcery_custom_rules(name_to_avoid)
+
+    rules_dict = {"rules": [rule.dict(exclude_unset=True) for rule in custom_rules]}
+    return yaml_converter.dumps(rules_dict)
+
+
+def create_sourcery_custom_rules(name_to_avoid: str) -> str:
+    description = f"Don't use the name {name_to_avoid}"
+
+    function_name_rule = SourceryCustomRule(
+        id=f"no-{name_to_avoid}-function-name",
+        description=description,
+        tags=["naming", f"no-{name_to_avoid}"],
+        pattern="""
+def ${function_name}(...):
+  ...
+""",
+        condition=f'function_name.contains("{name_to_avoid}")',
+    )
+
+    function_arg_rule = SourceryCustomRule(
+        id=f"no-{name_to_avoid}-function-arg",
+        description=description,
+        tags=["naming", f"no-{name_to_avoid}"],
+        pattern="""
+def ...(...,${arg_name}: ${type?} = ${default_value?},...):
+  ...
+""",
+        condition=f'arg_name.contains("{name_to_avoid}")',
+    )
+
+    class_name_rule = SourceryCustomRule(
+        id=f"no-{name_to_avoid}-class-name",
+        description=description,
+        tags=["naming", f"no-{name_to_avoid}"],
+        pattern="""
+class ${class_name}(...):
+  ...
+""",
+        condition=f'class_name.contains("{name_to_avoid}")',
+    )
+
+    variable_declaration_rule = SourceryCustomRule(
+        id=f"no-{name_to_avoid}-property",
+        description=description,
+        tags=["naming", f"no-{name_to_avoid}"],
+        pattern="${var}: ${type}",
+        condition=f'var.contains("{name_to_avoid}")',
+    )
+
+    variable_assignment_rule = SourceryCustomRule(
+        id=f"no-{name_to_avoid}-variable",
+        description=description,
+        tags=["naming", f"no-{name_to_avoid}"],
+        pattern="${var} = ${value}",
+        condition=f'var.contains("{name_to_avoid}")',
+    )
+
+    return (
+        function_name_rule,
+        function_arg_rule,
+        class_name_rule,
+        variable_declaration_rule,
+        variable_assignment_rule,
+    )

tests/test_version.py

@@ -2,4 +2,4 @@
 
 
 def test_version():
-    assert __version__ == "0.3.3"
+    assert __version__ == "0.4.0"

tests/unit/test_voldemort.py

@@ -0,0 +1,55 @@
+from sourcery_rules_generator import voldemort
+from sourcery_rules_generator.models import SourceryCustomRule
+
+
+def test_1_allowed_importer():
+    result = voldemort.create_sourcery_custom_rules("util")
+
+    expected = (
+        SourceryCustomRule(
+            id="no-util-function-name",
+            description="Don't use the name util",
+            tags=["naming", "no-util"],
+            pattern="""
+def ${function_name}(...):
+  ...
+""",
+            condition='function_name.contains("util")',
+        ),
+        SourceryCustomRule(
+            id="no-util-function-arg",
+            description="Don't use the name util",
+            tags=["naming", "no-util"],
+            pattern="""
+def ...(...,${arg_name}: ${type?} = ${default_value?},...):
+  ...
+""",
+            condition='arg_name.contains("util")',
+        ),
+        SourceryCustomRule(
+            id="no-util-class-name",
+            description="Don't use the name util",
+            tags=["naming", "no-util"],
+            pattern="""
+class ${class_name}(...):
+  ...
+""",
+            condition='class_name.contains("util")',
+        ),
+        SourceryCustomRule(
+            id="no-util-property",
+            description="Don't use the name util",
+            tags=["naming", "no-util"],
+            pattern="${var}: ${type}",
+            condition='var.contains("util")',
+        ),
+        SourceryCustomRule(
+            id="no-util-variable",
+            description="Don't use the name util",
+            tags=["naming", "no-util"],
+            pattern="${var} = ${value}",
+            condition='var.contains("util")',
+        ),
+    )
+
+    assert result == expected