python-code-validator 0.1.3__tar.gz → 0.2.1__tar.gz

{python_code_validator-0.1.3/src/python_code_validator.egg-info → python_code_validator-0.2.1}/PKG-INFO

@@ -1,30 +1,9 @@
 Metadata-Version: 2.4
 Name: python-code-validator
-Version: 0.1.3
+Version: 0.2.1
 Summary: A flexible, AST-based framework for static validation of Python code using declarative JSON rules.
 Author-email: Qu1nel <covach.qn@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2025 Ivan Kovach
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/Qu1nel/PythonCodeValidator
 Project-URL: Documentation, https://pythoncodevalidator.readthedocs.io/en/latest/
 Project-URL: Bug Tracker, https://github.com/Qu1nel/PythonCodeValidator/issues
@@ -35,7 +14,6 @@ Classifier: Intended Audience :: Education
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
@@ -287,7 +265,7 @@ Validation failed.
   **[Read the Docs](https://[your-project].readthedocs.io)**.
 - **Developer's Guide**: For a deep dive into the architecture, see the
   **[How It Works guide](./docs/how_it_works/index.md)**.
-- **Interactive AI-Powered Docs**: *(Coming Soon)* An interactive documentation experience.
+- **Interactive AI-Powered Docs**: **[DeepWiki](https://deepwiki.com/Qu1nel/PythonCodeValidator)**.
 
 ## 🤝 Contributing
 

{python_code_validator-0.1.3 → python_code_validator-0.2.1}/README.md

@@ -229,7 +229,7 @@ Validation failed.
   **[Read the Docs](https://[your-project].readthedocs.io)**.
 - **Developer's Guide**: For a deep dive into the architecture, see the
   **[How It Works guide](./docs/how_it_works/index.md)**.
-- **Interactive AI-Powered Docs**: *(Coming Soon)* An interactive documentation experience.
+- **Interactive AI-Powered Docs**: **[DeepWiki](https://deepwiki.com/Qu1nel/PythonCodeValidator)**.
 
 ## 🤝 Contributing
 
@@ -253,4 +253,4 @@ Email: **[covach.qn@gmail.com](mailto:covach.qn@gmail.com)** Telegram: **[@qnlln
 
 <br/>
 
-<p align="right"><a href="./LICENSE">MIT</a> © <a href="https://github.com/Qu1nel/">Ivan Kovach</a></p>
+<p align="right"><a href="./LICENSE">MIT</a> © <a href="https://github.com/Qu1nel/">Ivan Kovach</a></p>

{python_code_validator-0.1.3 → python_code_validator-0.2.1}/pyproject.toml

@@ -10,13 +10,14 @@ build-backend = "setuptools.build_meta"
 # ==============================================================================
 [project]
 name = "python-code-validator"
-version = "0.1.3"
-authors = [{ name = "Qu1nel", email = "covach.qn@gmail.com" }]
+version = "0.2.1"
 description = "A flexible, AST-based framework for static validation of Python code using declarative JSON rules."
+keywords = ["validation", "linter", "static analysis", "testing", "education", "ast"]
+authors = [{ name = "Qu1nel", email = "covach.qn@gmail.com" }]
 readme = "README.md"
 requires-python = ">=3.11"
-license = { file = "LICENSE" }
-keywords = ["validation", "linter", "static analysis", "testing", "education", "ast"]
+license-files = ["LICEN[CS]E*"]
+license = "MIT"
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
@@ -24,7 +25,6 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Topic :: Software Development :: Quality Assurance",
     "Topic :: Software Development :: Testing",
@@ -40,9 +40,11 @@ dependencies = [
 "Documentation" = "https://pythoncodevalidator.readthedocs.io/en/latest/"
 "Bug Tracker" = "https://github.com/Qu1nel/PythonCodeValidator/issues"
 
+
 [project.scripts]
 validate-code = "code_validator.cli:run_from_cli"
 
+
 [project.optional-dependencies]
 dev = [
     "ruff>=0.4.0",
@@ -81,8 +83,7 @@ select = [
     "C4", # flake8-comprehensions
     "D", # pydocstyle
 ]
-ignore = [
-]
+ignore = []
 
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = [
@@ -95,7 +96,7 @@ ignore = [
 ]
 "src/code_validator/components/__init__.py" = ["D104"]
 "src/code_validator/rules_library/__init__.py" = ["D104"]
-
+"src/code_validator/components/factories.py" = ["D107"]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"

{python_code_validator-0.1.3 → python_code_validator-0.2.1}/src/code_validator/__init__.py

@@ -54,4 +54,4 @@ __all__ = [
     "RuleParsingError",
 ]
 
-__version__ = "0.1.3"
+__version__ = "0.2.1"

{python_code_validator-0.1.3 → python_code_validator-0.2.1}/src/code_validator/cli.py

@@ -35,19 +35,22 @@ def setup_arg_parser() -> argparse.ArgumentParser:
         prog="validate-code",
         description="Validates a Python source file against a set of JSON rules.",
     )
+
     parser.add_argument("solution_path", type=Path, help="Path to the Python solution file to validate.")
     parser.add_argument("rules_path", type=Path, help="Path to the JSON file with validation rules.")
+
     parser.add_argument(
-        "-l",
-        "--log-level",
+        "--log",
         type=LogLevel,
-        choices=list(LogLevel),
-        default=LogLevel.WARNING,
-        help="Set the logging level (default: WARNING).",
+        default=LogLevel.ERROR,
+        help=("Set the logging level for stderr (TRACE, DEBUG, INFO, WARNING, ERROR, CRITICAL). Default: ERROR."),
     )
-    parser.add_argument("--silent", action="store_true", help="Suppress stdout output, show only logs.")
+    parser.add_argument(
+        "--quiet", action="store_true", help="Suppress all stdout output (validation errors and final verdict)."
+    )
+    parser.add_argument("--no-verdict", action="store_true", help="Suppress stdout output verdict, show failed rules.")
     parser.add_argument("--stop-on-first-fail", action="store_true", help="Stop after the first failed rule.")
-    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("--version", "-v", action="version", version=f"%(prog)s {__version__}")
     return parser
 
 
@@ -68,35 +71,42 @@ def run_from_cli() -> None:
     parser = setup_arg_parser()
     args = parser.parse_args()
 
-    logger = setup_logging(args.log_level)
-    console = Console(logger, is_silent=args.silent)
+    logger = setup_logging(args.log)
+    console = Console(logger, is_quiet=args.quiet, show_verdict=not args.no_verdict)
+    console.print(f"Level of logging: {args.log}", level=LogLevel.DEBUG)
     config = AppConfig(
         solution_path=args.solution_path,
         rules_path=args.rules_path,
-        log_level=args.log_level,
-        is_silent=args.silent,
+        log_level=args.log,
+        is_quiet=args.quiet,
         stop_on_first_fail=args.stop_on_first_fail,
     )
+    console.print(f"Config is: {config}", level=LogLevel.TRACE)
 
     try:
         console.print(f"Starting validation for: {config.solution_path}", level=LogLevel.INFO)
         validator = StaticValidator(config, console)
+
+        console.print("Start of validation..", level=LogLevel.TRACE)
         is_valid = validator.run()
+        console.print(f"End of validation with result: {is_valid = }", level=LogLevel.TRACE)
 
         if is_valid:
-            console.print("Validation successful.", level=LogLevel.INFO)
+            console.print("Validation successful.", level=LogLevel.INFO, is_verdict=True)
             sys.exit(ExitCode.SUCCESS)
         else:
-            console.print("Validation failed.", level=LogLevel.ERROR)
+            console.print("Validation failed.", level=LogLevel.INFO, is_verdict=True)
             sys.exit(ExitCode.VALIDATION_FAILED)
 
     except CodeValidatorError as e:
-        console.print(str(e), level=LogLevel.CRITICAL)
+        console.print("Error: Internal Error of validator!", level=LogLevel.CRITICAL)
+        logger.exception(f"Traceback for CodeValidatorError: {e}")
         sys.exit(ExitCode.VALIDATION_FAILED)
     except FileNotFoundError as e:
-        console.print(f"Error: File not found - {e.strerror}: {e.filename}", level=LogLevel.CRITICAL)
+        console.print(f"Error: File not found - {e.filename}!", level=LogLevel.CRITICAL)
+        logger.exception(f"Traceback for FileNotFoundError: {e}")
         sys.exit(ExitCode.FILE_NOT_FOUND)
     except Exception as e:
-        console.print(f"An unexpected error occurred: {e}", level=LogLevel.CRITICAL)
-        logger.exception("Traceback for unexpected error:")
+        console.print(f"An unexpected error occurred: {e.__class__.__name__}!", level=LogLevel.CRITICAL)
+        logger.exception(f"Traceback for unexpected error: {e}")
         sys.exit(ExitCode.UNEXPECTED_ERROR)

{python_code_validator-0.1.3 → python_code_validator-0.2.1}/src/code_validator/components/factories.py

@@ -10,9 +10,9 @@ rules file and instantiating the appropriate handler classes from the
 import dataclasses
 from typing import Any, Type, TypeVar
 
-from ..config import ConstraintConfig, FullRuleCheck, FullRuleConfig, SelectorConfig, ShortRuleConfig
+from ..config import ConstraintConfig, FullRuleCheck, FullRuleConfig, LogLevel, SelectorConfig, ShortRuleConfig
 from ..exceptions import RuleParsingError
-from ..output import Console
+from ..output import Console, log_initialization
 from ..rules_library.basic_rules import CheckLinterRule, CheckSyntaxRule, FullRuleHandler
 from ..rules_library.constraint_logic import (
     IsForbiddenConstraint,
@@ -71,6 +71,7 @@ class RuleFactory:
         _constraint_factory (ConstraintFactory): A factory for creating constraint objects.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
     def __init__(self, console: Console):
         """Initializes the RuleFactory.
 
@@ -101,8 +102,10 @@ class RuleFactory:
                 required keys, or specifies an unknown type.
         """
         rule_id = rule_config.get("rule_id")
+        self._console.print(f"Start parsing rule ({rule_id}):\n{rule_config}", level=LogLevel.TRACE)
         try:
             if "type" in rule_config:
+                self._console.print(f"Rule {rule_id} is shorted rule - {rule_config['type']}", level=LogLevel.DEBUG)
                 config = _create_dataclass_from_dict(ShortRuleConfig, rule_config)
                 return self._create_short_rule(config)
 
@@ -110,20 +113,31 @@ class RuleFactory:
                 raw_selector_cfg = rule_config["check"]["selector"]
                 raw_constraint_cfg = rule_config["check"]["constraint"]
 
-                selector = self._selector_factory.create(raw_selector_cfg)
-                constraint = self._constraint_factory.create(raw_constraint_cfg)
-
                 selector_cfg = _create_dataclass_from_dict(SelectorConfig, raw_selector_cfg)
                 constraint_cfg = _create_dataclass_from_dict(ConstraintConfig, raw_constraint_cfg)
+
+                selector = self._selector_factory.create(selector_cfg)
+                constraint = self._constraint_factory.create(constraint_cfg)
+
+                self._console.print(
+                    f"Rule {rule_id} is general rule with: selector - "
+                    f"{selector_cfg.type}, constraint - {raw_constraint_cfg['type']}",
+                    level=LogLevel.DEBUG,
+                )
+
                 check_cfg = FullRuleCheck(selector=selector_cfg, constraint=constraint_cfg)
+                self._console.print(f"Create FullRuleCheck: {check_cfg}", level=LogLevel.TRACE)
+
                 config = FullRuleConfig(
                     rule_id=rule_config["rule_id"],
                     message=rule_config["message"],
                     check=check_cfg,
                     is_critical=rule_config.get("is_critical", False),
                 )
+                self._console.print(f"Create FullRuleConfig: {config}", level=LogLevel.TRACE)
                 return FullRuleHandler(config, selector, constraint, self._console)
             else:
+                self._console.print(f"Invalid syntax of rule: {rule_id}", level=LogLevel.WARNING)
                 raise RuleParsingError("Rule must contain 'type' or 'check' key.", rule_id)
         except (TypeError, KeyError, RuleParsingError) as e:
             raise RuleParsingError(f"Invalid config for rule '{rule_id}': {e}", rule_id) from e
@@ -165,21 +179,23 @@ class SelectorFactory:
     any state.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
+    def __init__(self) -> None:
+        pass
+
     @staticmethod
-    def create(selector_config: dict[str, Any]) -> Selector:
+    def create(config: SelectorConfig) -> Selector:
         """Creates a specific selector instance based on its type.
 
         This method uses the 'type' field from the selector configuration
         to determine which concrete Selector class to instantiate.
 
         Args:
-            selector_config: The 'selector' block from a JSON rule.
+            config: The 'selector' block from a JSON rule.
 
         Returns:
             An instance of a class that conforms to the Selector protocol.
         """
-        config = _create_dataclass_from_dict(SelectorConfig, selector_config)
-
         match config.type:
             case "function_def":
                 return FunctionDefSelector(name=config.name, in_scope_config=config.in_scope)
@@ -210,21 +226,23 @@ class ConstraintFactory:
     to a list of AST nodes. This class uses a static `create` method.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
+    def __init__(self) -> None:
+        pass
+
     @staticmethod
-    def create(constraint_config: dict[str, Any]) -> Constraint:
+    def create(config: ConstraintConfig) -> Constraint:
         """Creates a specific constraint instance based on its type.
 
         This method uses the 'type' field from the constraint configuration
         to determine which concrete Constraint class to instantiate.
 
         Args:
-            constraint_config: The 'constraint' block from a JSON rule.
+            config: The 'constraint' block from a JSON rule.
 
         Returns:
             An instance of a class that conforms to the Constraint protocol.
         """
-        config = _create_dataclass_from_dict(ConstraintConfig, constraint_config)
-
         match config.type:
             case "is_required":
                 return IsRequiredConstraint(count=config.count)

{python_code_validator-0.1.3 → python_code_validator-0.2.1}/src/code_validator/config.py

@@ -25,6 +25,7 @@ class ExitCode(IntEnum):
 class LogLevel(StrEnum):
     """Defines the supported logging levels for the application."""
 
+    TRACE = "TRACE"
     DEBUG = "DEBUG"
     INFO = "INFO"
     WARNING = "WARNING"
@@ -40,14 +41,14 @@ class AppConfig:
         solution_path: The file path to the Python solution to be validated.
         rules_path: The file path to the JSON rules file.
         log_level: The minimum logging level for console output.
-        is_silent: If True, suppresses all non-log output to stdout.
+        is_quiet: If True, suppresses all non-log output to stdout.
         stop_on_first_fail: If True, halts validation after the first failed rule.
     """
 
     solution_path: Path
     rules_path: Path
     log_level: LogLevel
-    is_silent: bool
+    is_quiet: bool
     stop_on_first_fail: bool
 
 

{python_code_validator-0.1.3 → python_code_validator-0.2.1}/src/code_validator/core.py

@@ -45,9 +45,9 @@ import json
 from .components.ast_utils import enrich_ast_with_parents
 from .components.definitions import Rule
 from .components.factories import RuleFactory
-from .config import AppConfig, LogLevel
+from .config import AppConfig, LogLevel, ShortRuleConfig
 from .exceptions import RuleParsingError
-from .output import Console
+from .output import Console, log_initialization
 
 
 class StaticValidator:
@@ -67,6 +67,7 @@ class StaticValidator:
         _failed_rules (list[int]): A list of rule IDs that failed during the run.
     """
 
+    @log_initialization(level=LogLevel.DEBUG)
     def __init__(self, config: AppConfig, console: Console):
         """Initializes the StaticValidator.
 
@@ -77,6 +78,7 @@ class StaticValidator:
         """
         self._config = config
         self._console = console
+
         self._rule_factory = RuleFactory(self._console)
         self._source_code: str = ""
         self._ast_tree: ast.Module | None = None
@@ -95,39 +97,17 @@ class StaticValidator:
             FileNotFoundError: If the source file specified in the config does not exist.
             RuleParsingError: If the source file cannot be read for any other reason.
         """
-        self._console.print(f"Reading source file: {self._config.solution_path}")
+        self._console.print(f"Reading source file: {self._config.solution_path}", level=LogLevel.DEBUG)
         try:
             self._source_code = self._config.solution_path.read_text(encoding="utf-8")
+            self._console.print(f"Source code:\n{self._source_code}\n", level=LogLevel.TRACE)
         except FileNotFoundError:
+            self._console.print("During reading source file raised FileNotFound", level=LogLevel.TRACE)
             raise
         except Exception as e:
+            self._console.print("During reading source file raised some exception..", level=LogLevel.TRACE)
             raise RuleParsingError(f"Cannot read source file: {e}") from e
 
-    def _parse_ast_tree(self) -> bool:
-        """Parses the loaded source code into an AST and enriches it.
-
-        This method attempts to parse the source code. If successful, it calls
-        a helper to add parent references to each node in the tree, which is
-        crucial for many advanced checks. If a `SyntaxError` occurs, it
-        checks if a `check_syntax` rule was defined to provide a custom message.
-
-        Returns:
-            bool: True if parsing was successful, False otherwise.
-        """
-        self._console.print("Parsing Abstract Syntax Tree (AST)...")
-        try:
-            self._ast_tree = ast.parse(self._source_code)
-            enrich_ast_with_parents(self._ast_tree)
-            return True
-        except SyntaxError as e:
-            for rule in self._rules:
-                if getattr(rule.config, "type", None) == "check_syntax":
-                    self._console.print(rule.config.message, level=LogLevel.ERROR)
-                    self._failed_rules.append(rule.config.rule_id)
-                    return False
-            self._console.print(f"Syntax Error found: {e}", level=LogLevel.ERROR)
-            return False
-
     def _load_and_parse_rules(self) -> None:
         """Loads and parses the JSON file into executable Rule objects.
 
@@ -140,20 +120,52 @@ class StaticValidator:
             RuleParsingError: If the JSON is malformed or a rule configuration
                 is invalid.
         """
-        self._console.print(f"Loading rules from: {self._config.rules_path}")
+        self._console.print(f"Loading rules from: {self._config.rules_path}", level=LogLevel.DEBUG)
         try:
             rules_data = json.loads(self._config.rules_path.read_text(encoding="utf-8"))
+            self._console.print(f"Load rules:\n{rules_data}", level=LogLevel.TRACE)
             raw_rules = rules_data.get("validation_rules")
             if not isinstance(raw_rules, list):
                 raise RuleParsingError("`validation_rules` key not found or is not a list.")
 
+            self._console.print(f"Found {len(raw_rules)}.", level=LogLevel.DEBUG)
             self._rules = [self._rule_factory.create(rule) for rule in raw_rules]
-            self._console.print(f"Successfully parsed {len(self._rules)} rules.")
+            self._console.print(f"Successfully parsed {len(self._rules)} rules.", level=LogLevel.DEBUG)
         except json.JSONDecodeError as e:
+            self._console.print("During reading file of rules raised JsonDecodeError..", level=LogLevel.TRACE)
             raise RuleParsingError(f"Invalid JSON in rules file: {e}") from e
         except FileNotFoundError:
+            self._console.print("During reading file of rules raised FileNotFound", level=LogLevel.TRACE)
             raise
 
+    def _parse_ast_tree(self) -> bool:
+        """Parses the loaded source code into an AST and enriches it.
+
+        This method attempts to parse the source code. If successful, it calls
+        a helper to add parent references to each node in the tree, which is
+        crucial for many advanced checks. If a `SyntaxError` occurs, it
+        checks if a `check_syntax` rule was defined to provide a custom message.
+
+        Returns:
+            bool: True if parsing was successful, False otherwise.
+        """
+        self._console.print("Parsing Abstract Syntax Tree (AST)...", level=LogLevel.DEBUG)
+        try:
+            self._console.print("Start parse source code.", level=LogLevel.TRACE)
+            self._ast_tree = ast.parse(self._source_code)
+            enrich_ast_with_parents(self._ast_tree)
+            return True
+        except SyntaxError as e:
+            self._console.print("In source code SyntaxError..", level=LogLevel.TRACE)
+            for rule in self._rules:
+                if getattr(rule.config, "type", None) == "check_syntax":
+                    self._console.print(rule.config.message, level=LogLevel.ERROR, show_user=True)
+                    self._console.print(f"Failed rule id: {rule.config.rule_id}", level=LogLevel.DEBUG)
+                    self._failed_rules.append(rule.config.rule_id)
+                    return False
+            self._console.print(f"Syntax Error found: {e}", level=LogLevel.ERROR)
+            return False
+
     def run(self) -> bool:
         """Runs the entire validation process from start to finish.
 
@@ -174,20 +186,38 @@ class StaticValidator:
             if not self._parse_ast_tree():
                 return False
 
-        except (FileNotFoundError, RuleParsingError):
+            self._console.print("Lead source code, load and parse rules and parsing code - PASS", level=LogLevel.DEBUG)
+
+        except (FileNotFoundError, RuleParsingError) as e:
+            self._console.print(
+                f"In method `run` of 'StaticValidator' raised exception {e.__class__.__name__}", level=LogLevel.WARNING
+            )
             raise
 
+        self._console.print("Starting check rules..", level=LogLevel.DEBUG)
         for rule in self._rules:
             if getattr(rule.config, "type", None) == "check_syntax":
                 continue
 
-            self._console.print(f"Executing rule: {rule.config.rule_id}", level=LogLevel.DEBUG)
+            self._console.print(
+                f"Executing rule: {rule.config.rule_id}"
+                + (
+                    f" [{rule.config.check.selector.type}, {rule.config.check.constraint.type}, "
+                    f"is_critical={rule.config.is_critical}]"
+                    if not isinstance(rule.config, ShortRuleConfig)
+                    else ""
+                ),
+                level=LogLevel.INFO,
+            )
             is_passed = rule.execute(self._ast_tree, self._source_code)
             if not is_passed:
-                self._console.print(rule.config.message, level=LogLevel.ERROR)
+                self._console.print(rule.config.message, level=LogLevel.WARNING, show_user=True)
+                self._console.print(f"Rule {rule.config.rule_id} - FAIL", level=LogLevel.INFO)
                 self._failed_rules.append(rule.config.rule_id)
                 if getattr(rule.config, "is_critical", False) or self._config.stop_on_first_fail:
                     self._console.print("Critical rule failed. Halting validation.", level=LogLevel.WARNING)
                     break
+            else:
+                self._console.print(f"Rule {rule.config.rule_id} - PASS", level=LogLevel.INFO)
 
         return not self._failed_rules