diffnc 0.0.1__py3-none-any.whl

diffnc/vendors/_cisco_like.py

@@ -0,0 +1,203 @@
+"""Shared parser for Cisco-style "indent + ``!`` comments" vendors.
+
+IOS, NX-OS, IOS-XE, IOS-XR, and Arista EOS all share the same structural grammar:
+
+* Section heads (e.g. ``interface ...``, ``router ospf 1``) introduce nested children at
+  deeper indent. Indentation is significant; depth is determined by the stack of seen
+  indents, not by a fixed unit.
+* Lines starting with ``!`` or ``#`` are comments and discarded.
+* Some vendors use trailing keywords like ``end`` / ``exit`` / ``commit`` / ``root`` as
+  configuration terminators that should be ignored during parse.
+* ``shutdown`` / ``no shutdown`` form a tri-state per parent — the last toggle in input
+  order wins and only one of the two appears in the parent's children.
+* ``default <args>`` drops siblings under the current parent whose line equals or
+  token-prefix-matches ``<args>``.
+
+Vendors differ only in:
+
+* the rendered indent width (`indent_unit`)
+* which standalone keywords act as terminators (`terminators`)
+* the vendor name reported by :attr:`name`
+
+so this module exposes :class:`CiscoLikeParser` parameterised on those three knobs.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Iterator
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from diffnc.errors import ParseError
+from diffnc.ir import ConfigNode, ConfigTree
+from diffnc.vendors.base import VendorParser, render_subtree
+
+if TYPE_CHECKING:
+    from diffnc.reconcile import ReconcileEvent
+
+_DEFAULT_PREFIX = "default "
+_SHUT_STATES = ("shutdown", "no shutdown")
+
+
+def cisco_default_order_sensitive(path: tuple[str, ...]) -> bool:
+    """Path-based order-sensitivity shared by IOS / IOS-XE / IOS-XR / NX-OS / EOS.
+
+    ACL entries (``ip``/``ipv6``/``mac access-list``) and ``policy-map`` class blocks
+    are evaluated top-to-bottom in the order they appear; everything else (interfaces,
+    VRFs, ``route-map FOO permit <seq>`` siblings at top level, …) is order-insensitive.
+    """
+
+    if not path:
+        return False
+    head = path[-1]
+    if head.startswith(("ip access-list ", "ipv6 access-list ", "mac access-list ")):
+        return True
+    return head.startswith("policy-map ")
+
+
+@dataclass
+class CiscoLikeParser:
+    name: str
+    indent_unit: int
+    terminators: frozenset[str] = field(default_factory=frozenset)
+    order_sensitive_predicate: Callable[[tuple[str, ...]], bool] = field(
+        default=cisco_default_order_sensitive
+    )
+
+    def parse(self, text: str) -> ConfigTree:
+        tree = ConfigTree.empty(vendor=self.name)
+
+        stack: list[tuple[int, ConfigNode]] = [(-1, tree.root)]
+
+        for lineno, raw in enumerate(text.splitlines(), start=1):
+            stripped = raw.strip()
+            if not stripped or stripped.startswith("!") or stripped.startswith("#"):
+                continue
+            if stripped in self.terminators:
+                continue
+
+            indent = _leading_spaces(raw)
+
+            while stack and indent <= stack[-1][0]:
+                stack.pop()
+            if not stack:
+                raise ParseError(f"line {lineno}: unexpected indentation in {self.name} config")
+
+            parent_node = stack[-1][1]
+
+            if stripped == "default" or stripped.startswith(_DEFAULT_PREFIX):
+                path = stripped[len(_DEFAULT_PREFIX) :].strip() if stripped != "default" else ""
+                if not path:
+                    raise ParseError(f"line {lineno}: 'default' requires a path")
+                _apply_default(parent_node, path)
+                continue
+
+            if stripped in _SHUT_STATES:
+                _apply_shut_toggle(parent_node, stripped)
+                continue
+
+            actual = parent_node.add_child(ConfigNode(line=stripped))
+            stack.append((indent, actual))
+
+        return tree
+
+    def format(self, tree: ConfigTree) -> list[str]:
+        lines: list[str] = []
+        for child in tree.root.children:
+            lines.extend(render_subtree(self, child, depth=0))
+        return lines
+
+    def render_open(self, node: ConfigNode, depth: int) -> str:
+        return self._pad(depth) + node.line
+
+    def render_close(self, node: ConfigNode, depth: int) -> str | None:
+        return None
+
+    def render_leaf(self, node: ConfigNode, depth: int) -> str:
+        return self._pad(depth) + node.line
+
+    def is_order_sensitive(self, path: tuple[str, ...]) -> bool:
+        return self.order_sensitive_predicate(path)
+
+    def render_reconcile(self, events: Iterable[ReconcileEvent]) -> Iterator[str]:
+        from diffnc.reconcile import ReconcileAdd, ReconcileDelete, ReconcileRecreate
+
+        last_path: tuple[str, ...] | None = None
+        for ev in events:
+            if isinstance(ev, ReconcileRecreate):
+                parents = ev.section_path[:-1]
+                section_header = ev.section_path[-1]
+                yield from parents
+                yield f"no {section_header}"
+                yield from parents
+                yield section_header
+                for child in ev.new_node.children:
+                    yield from _walk_lines(child)
+                last_path = None
+                continue
+
+            if ev.parent_path != last_path:
+                yield from ev.parent_path
+                last_path = ev.parent_path
+
+            if isinstance(ev, ReconcileAdd):
+                yield from _walk_lines(ev.node)
+            elif isinstance(ev, ReconcileDelete):
+                yield _negate(ev.node.line)
+
+    def _pad(self, depth: int) -> str:
+        return " " * (self.indent_unit * depth)
+
+
+def _walk_lines(node: ConfigNode) -> Iterator[str]:
+    """Yield ``node.line`` followed by each descendant's line, pre-order."""
+
+    yield node.line
+    for child in node.children:
+        yield from _walk_lines(child)
+
+
+def _negate(line: str) -> str:
+    """Return the negation of *line* under Cisco's ``no`` semantics.
+
+    ``"description foo"`` → ``"no description foo"``; ``"no shutdown"`` → ``"shutdown"``.
+    Avoids ``"no no <foo>"`` double negation.
+    """
+
+    if line.startswith("no "):
+        return line[3:]
+    return f"no {line}"
+
+
+def _apply_shut_toggle(parent: ConfigNode, new_state: str) -> None:
+    """Toggle the shutdown/no-shutdown state under ``parent``.
+
+    Replaces any existing ``shutdown``/``no shutdown`` child line in place (preserving
+    first-occurrence position), or appends a new state node when none exists.
+    """
+
+    for child in parent.children:
+        if child.line in _SHUT_STATES:
+            child.line = new_state
+            return
+    parent.children.append(ConfigNode(line=new_state))
+
+
+def _apply_default(parent: ConfigNode, default_path: str) -> None:
+    """Drop ``parent``'s children whose line equals or token-prefix-matches ``default_path``."""
+
+    boundary = default_path + " "
+    surviving: list[ConfigNode] = []
+    for child in parent.children:
+        if child.line == default_path or child.line.startswith(boundary):
+            continue
+        surviving.append(child)
+    parent.children = surviving
+
+
+def _leading_spaces(line: str) -> int:
+    return len(line) - len(line.lstrip(" \t"))
+
+
+# Re-export for typing convenience.
+__all__ = ["CiscoLikeParser", "VendorParser", "cisco_default_order_sensitive"]

diffnc/vendors/base.py

@@ -0,0 +1,88 @@
+"""Vendor parser contract.
+
+A vendor plugin must expose:
+
+* :meth:`parse` — turn raw text into a normalised :class:`~diffnc.ir.ConfigTree`.
+* :meth:`format` — render a tree back to a list of display lines.
+* :meth:`render_open`, :meth:`render_close`, :meth:`render_leaf` — emit a single line at
+  the given indent depth. Used by the diff engine to splice context lines around changes
+  without re-rendering full subtrees.
+* :meth:`is_order_sensitive` (optional) — declare whether the children at a given
+  configuration path are order-sensitive. When ``False`` (the default), the diff engine
+  matches children as a multiset so that pure reordering does not produce a diff.
+
+Adding a new vendor is a matter of writing a module that implements :class:`VendorParser`
+and registering it via :mod:`diffnc.vendors`.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+from diffnc.ir import ConfigNode, ConfigTree
+
+if TYPE_CHECKING:
+    from diffnc.reconcile import ReconcileEvent
+
+
+@runtime_checkable
+class VendorParser(Protocol):
+    name: str
+    """Vendor identifier, e.g. ``"junos"`` or ``"nxos"``."""
+
+    def parse(self, text: str) -> ConfigTree: ...
+    def format(self, tree: ConfigTree) -> list[str]: ...
+    def render_open(self, node: ConfigNode, depth: int) -> str: ...
+    def render_close(self, node: ConfigNode, depth: int) -> str | None: ...
+    def render_leaf(self, node: ConfigNode, depth: int) -> str: ...
+
+    def is_order_sensitive(self, path: tuple[str, ...]) -> bool:
+        """Return True if the children at ``path`` must be diffed positionally.
+
+        ``path`` is the tuple of ``node.line`` values from root (exclusive) down to the
+        parent whose children are being matched — e.g. ``("firewall", "filter FOO")``.
+        Vendors that don't implement this fall back to order-insensitive matching.
+        """
+        ...
+
+    def render_reconcile(self, events: Iterable[ReconcileEvent]) -> Iterator[str]:
+        """Translate :mod:`diffnc.reconcile` events into config-mode command lines.
+
+        Optional. Parsers that don't implement this can still be used for diffing; only
+        :func:`diffnc.reconcile` will fail (with :class:`NotImplementedError`) when
+        called against them.
+        """
+        ...
+
+
+def is_order_sensitive_for(parser: VendorParser, path: tuple[str, ...]) -> bool:
+    """Resolve :meth:`VendorParser.is_order_sensitive` with a safe default.
+
+    Older / third-party parsers may not implement the method; treat such parents as
+    order-insensitive so the diff engine can fall back to multiset matching.
+    """
+
+    impl = getattr(parser, "is_order_sensitive", None)
+    if impl is None:
+        return False
+    return bool(impl(path))
+
+
+def render_subtree(
+    parser: VendorParser,
+    node: ConfigNode,
+    depth: int,
+) -> list[str]:
+    """Render *node* and all its descendants as display lines."""
+
+    if node.is_leaf:
+        return [parser.render_leaf(node, depth)]
+
+    lines = [parser.render_open(node, depth)]
+    for child in node.children:
+        lines.extend(render_subtree(parser, child, depth + 1))
+    close = parser.render_close(node, depth)
+    if close is not None:
+        lines.append(close)
+    return lines

diffnc/vendors/eos.py

@@ -0,0 +1,19 @@
+"""Arista EOS vendor parser.
+
+EOS configurations look very Cisco-ish — significant indentation, ``!`` comments,
+``end`` / ``exit`` terminators — but use a 3-space indent unit and a distinct top-level
+vocabulary (``vrf instance MGMT`` rather than NX-OS's ``vrf context``, ``daemon
+TerminAttr``, ``management api http-commands``, ...). The grammar itself is shared with
+the other Cisco-style vendors via :mod:`diffnc.vendors._cisco_like`.
+"""
+
+from __future__ import annotations
+
+from diffnc.vendors._cisco_like import CiscoLikeParser
+from diffnc.vendors.base import VendorParser
+
+PARSER: VendorParser = CiscoLikeParser(
+    name="eos",
+    indent_unit=3,
+    terminators=frozenset({"end", "exit"}),
+)

diffnc/vendors/ios.py

@@ -0,0 +1,19 @@
+"""Cisco IOS vendor parser.
+
+IOS configurations use significant indentation under section heads such as
+``interface GigabitEthernet0/0`` or ``router ospf 1`` with a 1-space indent unit, and
+end with ``end`` / ``exit`` terminator lines that we drop. Everything else (shutdown
+toggling, ``default`` semantics, ``!``/``#`` comment handling) is shared with the other
+Cisco-style vendors and lives in :mod:`diffnc.vendors._cisco_like`.
+"""
+
+from __future__ import annotations
+
+from diffnc.vendors._cisco_like import CiscoLikeParser
+from diffnc.vendors.base import VendorParser
+
+PARSER: VendorParser = CiscoLikeParser(
+    name="ios",
+    indent_unit=1,
+    terminators=frozenset({"end", "exit"}),
+)

diffnc/vendors/iosxe.py

@@ -0,0 +1,20 @@
+"""Cisco IOS-XE vendor parser.
+
+IOS-XE shares its CLI grammar with classic IOS — 1-space indentation, ``end`` / ``exit``
+terminators, ``!`` comments — but ships with a richer top-level vocabulary
+(``platform ...``, ``license boot level ...``, 3-tuple interface names like
+``GigabitEthernet0/0/0``). All of these structural rules are handled by the shared
+:class:`~diffnc.vendors._cisco_like.CiscoLikeParser`; only the auto-detection layer
+needs to know about the IOS-XE-specific markers.
+"""
+
+from __future__ import annotations
+
+from diffnc.vendors._cisco_like import CiscoLikeParser
+from diffnc.vendors.base import VendorParser
+
+PARSER: VendorParser = CiscoLikeParser(
+    name="iosxe",
+    indent_unit=1,
+    terminators=frozenset({"end", "exit"}),
+)

diffnc/vendors/iosxr.py

@@ -0,0 +1,19 @@
+"""Cisco IOS-XR vendor parser.
+
+IOS-XR uses the same indent-based section grammar as IOS (1-space unit) but has its own
+configuration session terminators — ``commit`` (and the less common ``root`` /
+``abort``) — that we treat the same way IOS treats ``end`` / ``exit``: drop them on
+parse. Interface naming conventions (``Bundle-Ether1``, 4-tuple ``GigabitEthernet0/0/0/0``)
+matter only for auto-detection and are handled in :mod:`diffnc.detect`.
+"""
+
+from __future__ import annotations
+
+from diffnc.vendors._cisco_like import CiscoLikeParser
+from diffnc.vendors.base import VendorParser
+
+PARSER: VendorParser = CiscoLikeParser(
+    name="iosxr",
+    indent_unit=1,
+    terminators=frozenset({"end", "exit", "commit", "root"}),
+)

diffnc/vendors/junos.py

@@ -0,0 +1,175 @@
+"""Junos hierarchical-form vendor parser.
+
+Handles the curly-brace form produced by ``show configuration``. Documents are modelled as
+a nested tree matching their brace structure, with same-named sibling blocks merged. The
+``inactive:`` prefix is preserved verbatim on the node line (mirroring how NX-OS keeps
+``no`` as part of its command line).
+
+Block comments (``/* ... */``) and line comments (``#``, ``//`` to end of line) are
+stripped during parsing.
+
+The set form (``display set`` output) is handled by a separate vendor, see
+:mod:`diffnc.vendors.junos_set`.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable, Iterator
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from diffnc.errors import ParseError
+from diffnc.ir import ConfigNode, ConfigTree
+from diffnc.vendors.base import VendorParser, render_subtree
+
+if TYPE_CHECKING:
+    from diffnc.reconcile import ReconcileEvent
+
+INDENT_UNIT = 4
+
+_BLOCK_COMMENT = re.compile(r"/\*.*?\*/", re.DOTALL)
+
+
+@dataclass
+class _JunosParser:
+    name: str = "junos"
+
+    def parse(self, text: str) -> ConfigTree:
+        cleaned = _BLOCK_COMMENT.sub("", text)
+        tree = ConfigTree.empty(vendor=self.name)
+        stack: list[ConfigNode] = [tree.root]
+
+        for lineno, raw in enumerate(cleaned.splitlines(), start=1):
+            stripped = _strip_line_comment(raw).strip()
+            if not stripped:
+                continue
+
+            if stripped == "}":
+                if len(stack) <= 1:
+                    raise ParseError(f"line {lineno}: unmatched '}}'")
+                stack.pop()
+                continue
+
+            if stripped.endswith("{"):
+                name = stripped[:-1].strip()
+                if not name:
+                    raise ParseError(f"line {lineno}: anonymous block")
+                actual = stack[-1].add_child(ConfigNode(line=name))
+                stack.append(actual)
+            elif stripped.endswith(";"):
+                name = stripped[:-1].strip()
+                if name:
+                    stack[-1].add_child(ConfigNode(line=name))
+            else:
+                raise ParseError(
+                    f"line {lineno}: unterminated statement (expected ';' or '{{'): {stripped!r}"
+                )
+
+        if len(stack) != 1:
+            raise ParseError("unclosed block at end of Junos hierarchical config")
+
+        return tree
+
+    def format(self, tree: ConfigTree) -> list[str]:
+        lines: list[str] = []
+        for child in tree.root.children:
+            lines.extend(render_subtree(self, child, depth=0))
+        return lines
+
+    def render_open(self, node: ConfigNode, depth: int) -> str:
+        return f"{_pad(depth)}{node.line} {{"
+
+    def render_close(self, node: ConfigNode, depth: int) -> str | None:
+        return f"{_pad(depth)}}}"
+
+    def render_leaf(self, node: ConfigNode, depth: int) -> str:
+        return f"{_pad(depth)}{node.line};"
+
+    def is_order_sensitive(self, path: tuple[str, ...]) -> bool:
+        """Term order matters inside firewall filters and policy-statements.
+
+        Junos evaluates ``term`` entries top-to-bottom, so a reorder changes behaviour
+        even when the term bodies are identical. Everything else in a Junos config is
+        a (named) container where ordering is purely cosmetic.
+        """
+
+        # firewall { filter <name> { term ... } }
+        if len(path) == 2 and path[0] == "firewall" and path[1].startswith("filter "):
+            return True
+        # firewall { family <fam> { filter <name> { term ... } } }
+        if (
+            len(path) == 3
+            and path[0] == "firewall"
+            and path[1].startswith("family ")
+            and path[2].startswith("filter ")
+        ):
+            return True
+        # policy-options { policy-statement <name> { term ... } }
+        return (
+            len(path) == 2
+            and path[0] == "policy-options"
+            and path[1].startswith("policy-statement ")
+        )
+
+    def render_reconcile(self, events: Iterable[ReconcileEvent]) -> Iterator[str]:
+        from diffnc.reconcile import ReconcileAdd, ReconcileDelete, ReconcileRecreate
+
+        for ev in events:
+            if isinstance(ev, ReconcileRecreate):
+                section = " ".join(ev.section_path)
+                yield f"delete {section}"
+                prefix = f"set {section} "
+                for child in ev.new_node.children:
+                    yield from _walk_set(prefix, child)
+                continue
+
+            base = " ".join(ev.parent_path)
+            base_with_sep = f"{base} " if base else ""
+
+            if isinstance(ev, ReconcileAdd):
+                yield from _walk_set(f"set {base_with_sep}", ev.node)
+            elif isinstance(ev, ReconcileDelete):
+                yield f"delete {base_with_sep}{ev.node.line}"
+
+
+def _walk_set(prefix: str, node: ConfigNode) -> Iterator[str]:
+    """Yield ``prefix + <leaf-path>`` for every leaf reachable from *node*.
+
+    Sections become an intermediate ``prefix + node.line + " "`` for their descendants.
+    """
+
+    if node.is_leaf:
+        yield prefix + node.line
+        return
+    next_prefix = f"{prefix}{node.line} "
+    for child in node.children:
+        yield from _walk_set(next_prefix, child)
+
+
+def _strip_line_comment(line: str) -> str:
+    """Truncate at the first ``#`` or ``//`` that lies outside a double-quoted string."""
+
+    in_quote = False
+    i = 0
+    n = len(line)
+    while i < n:
+        ch = line[i]
+        if ch == '"':
+            in_quote = not in_quote
+            i += 1
+            continue
+        if not in_quote:
+            if ch == "#":
+                return line[:i]
+            if ch == "/" and i + 1 < n and line[i + 1] == "/":
+                return line[:i]
+        i += 1
+    return line
+
+
+def _pad(depth: int) -> str:
+    return " " * (INDENT_UNIT * depth)
+
+
+PARSER: VendorParser = _JunosParser()