Change inline comment keyword from 'noqa' to 'noida'

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.

Author: claude

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,