feat: add AsciiDoc ifdef/ifndef conditional block support (#14)

Implement ifdef::attr[]/endif::[] and ifndef::attr[]/endif::[] conditional
blocks in the AsciiDoc parser. Supports block form, single-line form
(ifdef::attr[inline content]), and nested conditions with proper depth tracking.

Conditional filtering runs before include expansion, so ifdef can control
whether include directives are processed. Attributes defined via :attr: value
are tracked and available for condition evaluation.

Includes 25 new tests covering all conditional block scenarios.
Bump version to 0.4.27.

Fixes #14

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: raifdmueller

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dacli"
-version = "0.4.26"
+version = "0.4.27"
 description = "Documentation Access CLI - Navigate and query large documentation projects"
 readme = "README.md"
 license = { text = "MIT" }

src/dacli/__init__.py

@@ -5,4 +5,4 @@
 """
 
 
-__version__ = "0.4.26"
+__version__ = "0.4.27"

src/dacli/asciidoc_parser.py

@@ -50,6 +50,14 @@
 IMAGE_PATTERN = re.compile(r"^image::(.+?)\[(.*)?\]$")
 ADMONITION_PATTERN = re.compile(r"^(NOTE|TIP|IMPORTANT|WARNING|CAUTION):\s*(.*)$")
 
+# Conditional block patterns (Issue #14)
+# ifdef::attr[] or ifdef::attr[inline content]
+IFDEF_PATTERN = re.compile(r"^ifdef::([a-zA-Z0-9_-]+)\[(.*)\]$")
+# ifndef::attr[] or ifndef::attr[inline content]
+IFNDEF_PATTERN = re.compile(r"^ifndef::([a-zA-Z0-9_-]+)\[(.*)\]$")
+# endif::[] or endif::attr[]
+ENDIF_PATTERN = re.compile(r"^endif::([a-zA-Z0-9_-]*)?\[\]$")
+
 # Cross-reference pattern: <<target>> or <<target,display text>>
 XREF_PATTERN = re.compile(r"<<([^,>]+)(?:,([^>]+))?>>", re.MULTILINE)
 
@@ -266,6 +274,10 @@ def parse_file(
         # Parse attributes first (they can be used in sections)
         attributes = self._parse_attributes(lines)
 
+        # Filter conditional blocks (ifdef/ifndef/endif) before include expansion
+        # so that ifdef can control whether includes are processed (Issue #14)
+        lines = self._filter_conditionals(lines, attributes)
+
         # Expand includes and collect include info
         expanded_lines, includes = self._expand_includes(
             lines, file_path, _depth, current_chain
@@ -401,6 +413,103 @@ def _parse_attributes(self, lines: list[str]) -> dict[str, str]:
 
         return attributes
 
+    def _filter_conditionals(
+        self, lines: list[str], attributes: dict[str, str]
+    ) -> list[str]:
+        """Filter lines based on ifdef/ifndef/endif conditional blocks (Issue #14).
+
+        Processes conditional directives and returns only the lines that should
+        be included based on the current attribute definitions.
+
+        Supports:
+        - ifdef::attr[] / endif::[] - include when attribute is defined
+        - ifndef::attr[] / endif::[] - include when attribute is NOT defined
+        - Single-line form: ifdef::attr[content] / ifndef::attr[content]
+        - Nested conditions with proper depth tracking
+
+        Args:
+            lines: Raw document lines
+            attributes: Known document attributes
+
+        Returns:
+            Filtered list of lines with conditional directives removed
+        """
+        result: list[str] = []
+        # Stack of booleans: True = currently including content
+        # When empty, we're at top level (always including)
+        condition_stack: list[bool] = []
+
+        for line in lines:
+            stripped = line.strip()
+
+            # Check for ifdef::attr[] or ifdef::attr[inline content]
+            ifdef_match = IFDEF_PATTERN.match(stripped)
+            if ifdef_match:
+                attr_name = ifdef_match.group(1)
+                inline_content = ifdef_match.group(2)
+                condition_met = attr_name in attributes
+
+                if inline_content:
+                    # Single-line form: ifdef::attr[content]
+                    if self._is_including(condition_stack) and condition_met:
+                        attr_match = ATTRIBUTE_PATTERN.match(inline_content)
+                        if attr_match:
+                            attributes[attr_match.group(1)] = attr_match.group(2).strip()
+                        result.append(inline_content)
+                else:
+                    # Block form: push condition onto stack
+                    currently_including = self._is_including(condition_stack)
+                    condition_stack.append(currently_including and condition_met)
+                continue
+
+            # Check for ifndef::attr[] or ifndef::attr[inline content]
+            ifndef_match = IFNDEF_PATTERN.match(stripped)
+            if ifndef_match:
+                attr_name = ifndef_match.group(1)
+                inline_content = ifndef_match.group(2)
+                condition_met = attr_name not in attributes
+
+                if inline_content:
+                    # Single-line form: ifndef::attr[content]
+                    if self._is_including(condition_stack) and condition_met:
+                        attr_match = ATTRIBUTE_PATTERN.match(inline_content)
+                        if attr_match:
+                            attributes[attr_match.group(1)] = attr_match.group(2).strip()
+                        result.append(inline_content)
+                else:
+                    # Block form: push condition onto stack
+                    currently_including = self._is_including(condition_stack)
+                    condition_stack.append(currently_including and condition_met)
+                continue
+
+            # Check for endif::[] or endif::attr[]
+            endif_match = ENDIF_PATTERN.match(stripped)
+            if endif_match:
+                if condition_stack:
+                    condition_stack.pop()
+                continue
+
+            # Track attribute definitions inside conditional blocks
+            if self._is_including(condition_stack):
+                attr_match = ATTRIBUTE_PATTERN.match(line)
+                if attr_match:
+                    attributes[attr_match.group(1)] = attr_match.group(2).strip()
+                result.append(line)
+
+        return result
+
+    @staticmethod
+    def _is_including(condition_stack: list[bool]) -> bool:
+        """Check if we're currently in an including state.
+
+        Args:
+            condition_stack: Stack of condition states
+
+        Returns:
+            True if all conditions in the stack are True (or stack is empty)
+        """
+        return not condition_stack or condition_stack[-1]
+
     def _substitute_attributes(self, text: str, attributes: dict[str, str]) -> str:
         """Substitute attribute references in text.
 

src/docs/spec/05_asciidoc_parser.adoc

@@ -33,25 +33,16 @@ The parser is **not** a complete Asciidoctor renderer. It:
 * Does not parse inline formatting (bold, italic, monospace)
 * Does not analyze table contents in detail
 * Does not process complex list structures
-* Does **not** support conditional blocks (`ifdef::`, `ifndef::`, `ifeval::`)
+* Does **not** support `ifeval::[]` conditional evaluation
 
 == Technical Debt
 
 [WARNING]
 ====
-**TD-ADOC-001: Conditional Blocks Not Supported**
+**TD-ADOC-001: ifeval Conditional Not Supported**
 
-The following AsciiDoc features are **not** supported in this version:
-
-* `ifdef::attr[]` / `endif::[]`
-* `ifndef::attr[]` / `endif::[]`
-* `ifeval::[]`
-
-These features are relevant for complex documentation projects with conditional output. A later implementation should:
-
-1. Evaluate attribute-based conditions
-2. Be able to show/hide conditional blocks
-3. Handle nested conditions
+The `ifeval::[]` directive is **not** supported in this version.
+`ifdef::attr[]` / `ifndef::attr[]` / `endif::[]` are fully supported (Issue #14).
 
 **Priority:** Low (not required for MVP)
 ====
@@ -134,7 +125,7 @@ These features are relevant for complex documentation projects with conditional
 
 === Not Supported
 
-* Conditional blocks (`ifdef::`, `ifndef::`, `ifeval::`) - see Technical Debt
+* `ifeval::[]` conditional evaluation - see Technical Debt
 * Inline formatting (`*bold*`, `_italic_`, `+mono+`)
 * Footnotes
 * Bibliography