Change inline comment keyword from 'noqa' to 'noida' (#31)

Replace the 'noqa' keyword with 'noida' to avoid conflicts with ruff.
Ruff doesn't accept 'noqa' comments that don't match ruff rules, so
using a custom keyword 'noida' (no-oida) prevents these conflicts.

Changes:
- Renamed parse_noqa_comment() to parse_noida_comment()
- Updated regex to match 'noida' instead of 'noqa'
- Updated all tests to use 'noida' keyword
- Updated README.md documentation
- Added BREAKING CHANGE note in CHANGELOG.md

This is a breaking change - users must replace all '# noqa' comments
with '# noida' comments in their code.

Co-authored-by: Claude <noreply@anthropic.com>

Author: Morten Krane

CHANGELOG.md

@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+- **BREAKING**: Changed inline comment keyword from `# noqa` to `# noida` to avoid conflicts with ruff, which doesn't accept `noqa` comments that don't match ruff rules
+
 ## [0.3.0] - 2025-11-25
 
 ### Added

README.md

@@ -41,7 +41,7 @@ an existing codebase into one that's modularized. For details see `oida
 ### `oida lint`
 
 This command is just another way of running the same checks that can be run
-through `flake8`. This command supports `# noqa` comments to ignore specific
+through `flake8`. This command supports `# noida` comments to ignore specific
 violations on individual lines (see below for details).
 
 ### `oida config`
@@ -101,23 +101,24 @@ This will silence any warnings when importing `my_component.app.models.MyModel`
 in the current app/component.
 
 
-## Ignoring Violations with `# noqa` Comments
+## Ignoring Violations with `# noida` Comments
 
-You can use inline `# noqa` comments to ignore specific violations on individual lines:
+You can use inline `# noida` comments to ignore specific violations on individual lines:
 
 ```python
 # Ignore all violations on this line
-from project.other_component.app.models import Model  # noqa
+from project.other_component.app.models import Model  # noida
 
 # Ignore a specific violation code
-from project.other_component.app.models import Model  # noqa: ODA005
+from project.other_component.app.models import Model  # noida: ODA005
 
 # Ignore multiple specific violation codes
-from project.other_component.app.models import Model  # noqa: ODA005, ODA001
+from project.other_component.app.models import Model  # noida: ODA005, ODA001
 ```
 
-The `# noqa` comments work with both the `oida lint` command and when used as a
-flake8 plugin.
+The `# noida` comments work with the `oida lint` command. Note that we use `noida`
+instead of `noqa` to avoid conflicts with ruff, which doesn't accept `noqa` comments
+that don't match ruff rules.
 
 
 ## Checks

oida/checkers/base.py

@@ -3,7 +3,7 @@
 from typing import ClassVar, NamedTuple
 
 from ..config import ComponentConfig, ProjectConfig
-from ..utils import parse_noqa_comment
+from ..utils import parse_noida_comment
 
 
 class Code(int, enum.Enum):
@@ -42,24 +42,24 @@ def __init__(
         self.violations: list[Violation] = []
 
     def _should_ignore_violation(self, line: int, code: Code) -> bool:
-        """Check if a violation should be ignored due to a noqa comment."""
+        """Check if a violation should be ignored due to a noida comment."""
         if self.source_lines is None or line < 1 or line > len(self.source_lines):
             return False
 
         source_line = self.source_lines[line - 1]  # Convert 1-indexed to 0-indexed
-        noqa_codes = parse_noqa_comment(source_line)
+        noida_codes = parse_noida_comment(source_line)
 
-        if noqa_codes is None:
-            # No noqa comment
+        if noida_codes is None:
+            # No noida comment
             return False
 
-        if not noqa_codes:
-            # "# noqa" without specific codes - ignore all violations
+        if not noida_codes:
+            # "# noida" without specific codes - ignore all violations
             return True
 
         # Check if this specific code should be ignored
         code_str = f"ODA{code.value:03d}"
-        return code_str in noqa_codes
+        return code_str in noida_codes
 
     def report_violation(self, node: ast.AST, code: Code, message: str) -> None:
         if self._should_ignore_violation(node.lineno, code):

oida/utils.py

@@ -36,35 +36,35 @@ def path_in_glob_list(path: str, glob_list: list[str]) -> bool:
     return False
 
 
-def parse_noqa_comment(line: str) -> set[str] | None:
+def parse_noida_comment(line: str) -> set[str] | None:
     """
-    Parse a noqa comment from a line of source code.
+    Parse a noida comment from a line of source code.
 
     Returns:
-        - None if no noqa comment is found
-        - Empty set if "# noqa" (ignore all violations)
-        - Set of specific codes if "# noqa: ODA001,ODA002" (ignore specific codes)
+        - None if no noida comment is found
+        - Empty set if "# noida" (ignore all violations)
+        - Set of specific codes if "# noida: ODA001,ODA002" (ignore specific codes)
 
     Examples:
-        >>> parse_noqa_comment("x = 1  # noqa")
+        >>> parse_noida_comment("x = 1  # noida")
         set()
-        >>> parse_noqa_comment("x = 1  # noqa: ODA005")
+        >>> parse_noida_comment("x = 1  # noida: ODA005")
         {'ODA005'}
-        >>> parse_noqa_comment("x = 1  # noqa: ODA005, ODA001")
+        >>> parse_noida_comment("x = 1  # noida: ODA005, ODA001")
         {'ODA005', 'ODA001'}
-        >>> parse_noqa_comment("x = 1  # regular comment")
+        >>> parse_noida_comment("x = 1  # regular comment")
         None
     """
-    # Match "# noqa" optionally followed by ": CODE1, CODE2, ..."
-    # Case-insensitive matching for "noqa"
-    match = re.search(r"#\s*noqa(?::\s*([A-Z0-9,\s]+))?", line, re.IGNORECASE)
+    # Match "# noida" optionally followed by ": CODE1, CODE2, ..."
+    # Case-insensitive matching for "noida"
+    match = re.search(r"#\s*noida(?::\s*([A-Z0-9,\s]+))?", line, re.IGNORECASE)
 
     if not match:
         return None
 
     codes_str = match.group(1)
     if not codes_str:
-        # "# noqa" without specific codes - ignore all
+        # "# noida" without specific codes - ignore all
         return set()
 
     # Parse the comma-separated list of codes

tests/test_noqa.py

@@ -1,36 +1,36 @@
 import pytest
 
 from oida.checkers import Code, ComponentIsolationChecker, Violation
-from oida.utils import parse_noqa_comment
+from oida.utils import parse_noida_comment
 
 pytestmark = pytest.mark.module(name="selectors", module="project.component.app")
 
 
-def test_parse_noqa_comment_no_comment() -> None:
-    """Test parsing line without noqa comment"""
-    assert parse_noqa_comment("x = 1") is None
-    assert parse_noqa_comment("from foo import bar") is None
+def test_parse_noida_comment_no_comment() -> None:
+    """Test parsing line without noida comment"""
+    assert parse_noida_comment("x = 1") is None
+    assert parse_noida_comment("from foo import bar") is None
 
 
-def test_parse_noqa_comment_generic() -> None:
-    """Test parsing generic noqa comment"""
-    assert parse_noqa_comment("x = 1  # noqa") == set()
-    assert parse_noqa_comment("x = 1  #noqa") == set()
-    assert parse_noqa_comment("x = 1  # NOQA") == set()
+def test_parse_noida_comment_generic() -> None:
+    """Test parsing generic noida comment"""
+    assert parse_noida_comment("x = 1  # noida") == set()
+    assert parse_noida_comment("x = 1  #noida") == set()
+    assert parse_noida_comment("x = 1  # NOIDA") == set()
 
 
-def test_parse_noqa_comment_specific_code() -> None:
-    """Test parsing noqa comment with specific code"""
-    assert parse_noqa_comment("x = 1  # noqa: ODA005") == {"ODA005"}
-    assert parse_noqa_comment("x = 1  # noqa:ODA005") == {"ODA005"}
-    assert parse_noqa_comment("x = 1  # NOQA: ODA005") == {"ODA005"}
+def test_parse_noida_comment_specific_code() -> None:
+    """Test parsing noida comment with specific code"""
+    assert parse_noida_comment("x = 1  # noida: ODA005") == {"ODA005"}
+    assert parse_noida_comment("x = 1  # noida:ODA005") == {"ODA005"}
+    assert parse_noida_comment("x = 1  # NOIDA: ODA005") == {"ODA005"}
 
 
-def test_parse_noqa_comment_multiple_codes() -> None:
-    """Test parsing noqa comment with multiple codes"""
-    assert parse_noqa_comment("x = 1  # noqa: ODA005, ODA001") == {"ODA005", "ODA001"}
-    assert parse_noqa_comment("x = 1  # noqa: ODA005,ODA001") == {"ODA005", "ODA001"}
-    assert parse_noqa_comment("x = 1  # noqa: ODA005 , ODA001") == {
+def test_parse_noida_comment_multiple_codes() -> None:
+    """Test parsing noida comment with multiple codes"""
+    assert parse_noida_comment("x = 1  # noida: ODA005, ODA001") == {"ODA005", "ODA001"}
+    assert parse_noida_comment("x = 1  # noida: ODA005,ODA001") == {"ODA005", "ODA001"}
+    assert parse_noida_comment("x = 1  # noida: ODA005 , ODA001") == {
         "ODA005",
         "ODA001",
     }
@@ -39,41 +39,41 @@ def test_parse_noqa_comment_multiple_codes() -> None:
 @pytest.mark.module(
     """\
     from project.other.app.services import service
-    service()  # noqa
+    service()  # noida
     """
 )
-def test_noqa_generic_ignores_violation(
+def test_noida_generic_ignores_violation(
     checker: ComponentIsolationChecker, violations: list[Violation]
 ) -> None:
-    """Test that generic noqa comment ignores all violations on that line"""
+    """Test that generic noida comment ignores all violations on that line"""
     assert violations == []
     assert checker.referenced_imports == {"project.other.app.services.service"}
 
 
 @pytest.mark.module(
     """\
     from project.other.app.services import service
-    service()  # noqa: ODA005
+    service()  # noida: ODA005
     """
 )
-def test_noqa_specific_code_ignores_violation(
+def test_noida_specific_code_ignores_violation(
     checker: ComponentIsolationChecker, violations: list[Violation]
 ) -> None:
-    """Test that specific noqa comment ignores matching violation"""
+    """Test that specific noida comment ignores matching violation"""
     assert violations == []
     assert checker.referenced_imports == {"project.other.app.services.service"}
 
 
 @pytest.mark.module(
     """\
     from project.other.app.services import service
-    service()  # noqa: ODA001
+    service()  # noida: ODA001
     """
 )
-def test_noqa_different_code_does_not_ignore(
+def test_noida_different_code_does_not_ignore(
     checker: ComponentIsolationChecker, violations: list[Violation]
 ) -> None:
-    """Test that noqa comment with different code does not ignore violation"""
+    """Test that noida comment with different code does not ignore violation"""
     assert violations == [
         Violation(
             line=2,
@@ -88,13 +88,13 @@ def test_noqa_different_code_does_not_ignore(
 @pytest.mark.module(
     """\
     from project.other.app.services import service
-    service()  # noqa: ODA005, ODA001
+    service()  # noida: ODA005, ODA001
     """
 )
-def test_noqa_multiple_codes_ignores_matching(
+def test_noida_multiple_codes_ignores_matching(
     checker: ComponentIsolationChecker, violations: list[Violation]
 ) -> None:
-    """Test that noqa comment with multiple codes ignores matching violation"""
+    """Test that noida comment with multiple codes ignores matching violation"""
     assert violations == []
     assert checker.referenced_imports == {"project.other.app.services.service"}
 
@@ -104,13 +104,13 @@ def test_noqa_multiple_codes_ignores_matching(
     from project.other.app.models import Model
 
     def selector() -> None:
-        Model.objects.get()  # noqa: ODA005
+        Model.objects.get()  # noida: ODA005
     """
 )
-def test_noqa_in_function_body(
+def test_noida_in_function_body(
     checker: ComponentIsolationChecker, violations: list[Violation]
 ) -> None:
-    """Test that noqa comment works in function bodies"""
+    """Test that noida comment works in function bodies"""
     assert violations == []
     assert checker.referenced_imports == {"project.other.app.models.Model"}
 
@@ -121,13 +121,13 @@ def test_noqa_in_function_body(
 
     def selector() -> None:
         Model.objects.get()
-        Model.objects.filter()  # noqa
+        Model.objects.filter()  # noida
     """
 )
-def test_noqa_only_affects_its_line(
+def test_noida_only_affects_its_line(
     checker: ComponentIsolationChecker, violations: list[Violation]
 ) -> None:
-    """Test that noqa comment only affects violations on its own line"""
+    """Test that noida comment only affects violations on its own line"""
     assert violations == [
         Violation(
             line=4,