ctx_parser 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fa31bb20dcff8d61e0855e926e92be68473aa7b3bc33fea86e95bfd08caaac8
-  data.tar.gz: 02d5738230c47a01921c8e2f530bfe4acc740f607f46fe3677c355092cd3e068
+  metadata.gz: 34175c1684f6dc5b5a7ef9a12649f16d393965f87c506d1f672f63a8301a7ebd
+  data.tar.gz: 55f14e3f497e6a3fa5484f6e5465effc39acadcfff0e908932abe41b43696b94
 SHA512:
-  metadata.gz: af7037925fd0ecdaccb72464cdcab399daeb35e3939e51e72b7a53fedd3f55f5962f390bac4a1558c0f704e2995c7fe526e4d1fd7c3411bed068fd34671a9b4b
-  data.tar.gz: 1a7fc7f989267dcde2c9f9d4b0f6e7abe59348ffbcca529ae73c0425043ec36fcbff70ebd14d8b92931bcb823d4a4970454d61c36d5f198539b61e5a551842cb
+  metadata.gz: fc1d527a3d2a6a0c2001bfc270d6afb7f8b21e3f779d5f61b31de69757ea598f2b255a5a5eb15db41ebde8de6274c99e3ade55f89cb1b577041cdab8d4563bbf
+  data.tar.gz: 4708ac383d49d5f2ade14747800d6d5d52db0e1cdc78ac2acbd87e828fb41695e41ebf2a98a72b1c81c13d4612c2419e40ba189d429c39be7bb4afebd074100c

data/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 Changes to the public contract are recorded here. Versions follow Semantic Versioning.
 
+## 0.2.1 (2026-10-17)
+
+- Update the configuration benchmark to use the Baseline 0.2 vendor parser namespace.
+
+## 0.2.0 (2026-10-17)
+
+- Validate integer inputs and bound types without implicit object conversion; reject mixed MAC separators.
+- Strip hash defaults from result dimension maps and reject non-hash registry declarations at the public boundary.
+- Append owned command indexes in place during construction and avoid reselecting an already validated command during profile parsing.
+
+- Keep result interpolation redacted and reject malformed diagnostic collections.
+- Detach nested document diagnostics and reject custom mutable numeric values in fact snapshots, including Complex components.
+- Validate child block ownership, containment, and source order before accepting a source tree.
+- Short-circuit block completeness queries without allocating line and state arrays; retain live cursor semantics.
+
+- Reject unnamed or non-symbol result dimensions before profile selection.
+
+- Use `Configuration`, `Results`, and `Commands` consistently; keep configuration source state in `Configuration` and name dimension indexes `by_dimension`.
+
+- Require a boolean `allow_zone` option so string values cannot enable scoped IPv6 addresses.
+
+- Reject nontext address identities and nonboolean host-bit preservation policies at the scalar boundary.
+
+- Rename domain APIs directly; callers must use the new names (no compatibility aliases).
+
+- Clarify dimension-to-command planning, model parser overrides, and record identity grouping names.
+
+- Copy shared fact containers once, reject cyclic values with `ArgumentError`, and support deeply nested snapshots without exhausting the Ruby call stack.
+- Preserve valid UTF-16/32 source encodings while checking logical NUL characters and normalizing requested line endings.
+
 ## 0.1.1 (2026-10-16)
 
 - Publish verified artifacts using either an environment API key or RubyGems Trusted Publishing.

data/README-zh.md

@@ -6,9 +6,9 @@
 
 ## 能力
 
-- `Parser`、`ConfigurationParser` 定义文本输入及完整性边界。
+- `Parser`、`Configuration` 定义文本输入及完整性边界。
 - `Cursor`、`Document`、`Capture` 保留来源位置和嵌套配置上下文。
-- `Profile`、`CommandCatalog`、`Registry` 声明平台/型号行为，同一回显可共享解析。
+- `Profile`、`Commands`、`Registry` 声明平台/型号行为，同一回显可共享解析。
 - `Values`、`Records`、`Immutable` 统一值转换、身份检查与防御性复制。
 
 ## 安装
@@ -68,16 +68,26 @@ result.records.each { |row| puts "#{row[:name]}: #{row[:state]}" }
 
 ## 公开契约与限制
 
-`Parser.parse(text, complete: false)` 返回包含 `status`、`records`、`issues` 的 `Result`；多视图解析器可返回 `ResultSet`。状态为 `complete`、`partial`、`failed`、`unsupported`。子类实现 `parse_output`，配置子类通过 `analyze` 和 `capture` 保留来源。
+`Parser.parse(text, complete: false)` 返回包含 `status`、`records`、`issues` 的 `Result`；多视图解析器可返回 `Results`。状态为 `complete`、`partial`、`failed`、`unsupported`。子类实现 `parse_output`，配置子类通过 `analyze` 和 `capture` 保留来源。
 
-`complete: true` 只表示调用方确认输入完整接收，不证明所有语法都已理解。未知行、身份冲突及空表证据不足必须明确表达。结果不可变；来源游标有意保留输入原文，含秘密时不可写入日志。
+`complete: true` 只表示调用方确认输入完整接收，不证明所有语法都已理解。未知行、身份冲突及空表证据不足必须明确表达。结果的记录和诊断均须为 Hash 数组；结果及构建完成的文档诊断持有不可变快照。`inspect` 和 `to_s` 不输出结果正文与诊断内容，显式读取记录仍返回原始事实。来源游标有意保留输入原文，含秘密时不可写入日志。
 
 本 gem 不提供厂商命令目录、传输、持久化或健康策略。参数和注册表配置错误保持异常，由调用方在对应边界处理。
 
 详细厂商语义、历史验证记录和 Motor 专用集成说明保留在[架构参考](docs/architecture-zh.md)。其中宿主集成代码需要 Motor，不属于独立 gem API。适配层位于 [Motor 仓库](https://github.com/gatework/motor/tree/main/backend/lib) 的 `backend/lib/baseline`、`backend/lib/vxlan` 和 `backend/lib/wireless`。
 
+## 领域术语
+
+名称使用领域名词：`Configuration` 解析配置文档，`Result` 表示单个结果，`Results` 保存具名结果，`Commands` 保存命令声明。两个集合均用 `by_dimension` 表示维度索引。通用 `Parser` 负责文本解析契约，配置来源状态归 `Configuration` 管理。
+
+维度是具名事实视图，命令是提供这些事实的 CLI 查询。`Profile#queries` 按命令归组维度，型号覆盖按命令选择解析器。`Records` 按逻辑身份归组记录；重复身份数与多余记录数是不同数量。`Line`、`Block`、`Capture` 保留来源位置，`Result` 承载归一化事实与诊断。解析完整性或空结果都不能证明设备健康。
+
+地址转换使用 `Values.ip_address`、`Values.ip_address?`、`Values.mac_address`。`Values.ipv4_prefix(..., preserve_host_bits: true)` 明确保留接口主机位，默认返回网段前缀。
+
 ## 开发与测试
 
+共享类按实际职责命名，平台信息放在命名空间中。直接对应设备命令的解析器保留文件名和类名。
+
 ```sh
 bundle install
 bundle exec rake

data/README.md

@@ -2,13 +2,13 @@
 
 [简体中文](README-zh.md) | [Source](https://github.com/gatework/ctx_parser) | [Changelog](CHANGELOG.md)
 
-Shared, pure Ruby building blocks for network CLI parsing. It provides immutable results, source cursors, configuration trees, command catalogs, and platform profiles without owning vendor syntax or device sessions.
+Shared, pure Ruby building blocks for network CLI parsing. It provides immutable results, source cursors, configuration trees, command declarations, and platform profiles without owning vendor syntax or device sessions.
 
 ## Features
 
-- `Parser` and `ConfigurationParser` define explicit text and completeness boundaries.
+- `Parser` and `Configuration` define explicit text and completeness boundaries.
 - `Cursor`, `Document`, and `Capture` preserve source positions and nested configuration context.
-- `Profile`, `CommandCatalog`, and `Registry` select declared platform/model behavior and share parsing across views.
+- `Profile`, `Commands`, and `Registry` select declared platform/model behavior and share parsing across views.
 - `Values`, `Records`, and `Immutable` centralize conversion, identity checks, and defensive copies.
 
 ## Installation
@@ -68,16 +68,26 @@ result.records.each { |row| puts "#{row[:name]}: #{row[:state]}" }
 
 ## Public contract and limits
 
-`Parser.parse(text, complete: false)` returns a `Result` with `status`, `records`, and `issues`; a multi-view parser can return `ResultSet`. Result statuses are `complete`, `partial`, `failed`, and `unsupported`. Subclasses implement `parse_output`. Configuration subclasses can use `analyze` and `capture` to preserve provenance.
+`Parser.parse(text, complete: false)` returns a `Result` with `status`, `records`, and `issues`; a multi-view parser can return `Results`. Result statuses are `complete`, `partial`, `failed`, and `unsupported`. Subclasses implement `parse_output`. Configuration subclasses can use `analyze` and `capture` to preserve provenance.
 
-`complete: true` confirms that the caller received the entire input; it does not certify that all syntax was understood. Unknown rows, identity conflicts, and insufficient empty-table evidence must remain explicit. Results are immutable. Source cursors intentionally retain original input and must not be logged when it contains secrets.
+`complete: true` confirms that the caller received the entire input; it does not certify that all syntax was understood. Unknown rows, identity conflicts, and insufficient empty-table evidence must remain explicit. Result records and issues must be arrays of hashes. Results and completed document diagnostics own immutable snapshots. `inspect` and `to_s` omit result facts and diagnostics; explicit record access still returns the original facts. Source cursors intentionally retain original input and must not be logged when it contains secrets.
 
-This gem supplies no vendor command catalog, transport, persistence, or health policy. Parser/registry argument errors remain exceptions for callers to handle at their own boundary.
+This gem supplies no vendor command declarations, transport, persistence, or health policy. Parser/registry argument errors remain exceptions for callers to handle at their own boundary.
 
 Detailed vendor behavior, historical validation notes, and Motor-only integration are preserved in [the architecture reference](docs/architecture-zh.md). Host integration examples in that reference require Motor; they are not standalone gem APIs. Motor adapters live under `backend/lib/baseline`, `backend/lib/vxlan`, and `backend/lib/wireless` in the [Motor repository](https://github.com/gatework/motor/tree/main/backend/lib).
 
+## Domain vocabulary
+
+Names use domain nouns: `Configuration` parses configuration documents; `Result` holds one result and `Results` holds named results; `Commands` stores command declarations. Both collections expose their dimension index as `by_dimension`. Generic `Parser` owns the text parsing contract; configuration source state belongs to `Configuration`.
+
+A dimension is a named view of facts; a command is the CLI query that supplies those facts. `Profile#queries` groups dimensions by command, and model overrides choose parsers for commands. `Records` groups rows by logical identity; duplicate identity counts and redundant row counts are different quantities. `Line`, `Block`, and `Capture` retain source locations, while `Result` contains normalized facts and diagnostics. Neither parsing completeness nor an empty result establishes device health.
+
+Address conversion uses `Values.ip_address`, `Values.ip_address?`, and `Values.mac_address`. `Values.ipv4_prefix(..., preserve_host_bits: true)` explicitly preserves interface host bits; its default returns a network prefix.
+
 ## Development and tests
 
+Name shared classes by their responsibility and use the namespace for platform context. Preserve filenames and class names that directly match device commands.
+
 ```sh
 bundle install
 bundle exec rake

data/docs/architecture-zh.md

@@ -11,7 +11,7 @@
 | 对象 | 职责 |
 | --- | --- |
 | `Parser` | 统一 `.parse(text, complete: false)` 接口和参数校验；具体策略实现 `parse_output` |
-| `ConfigurationParser` | 共用配置节点状态标记、来源捕获和嵌套路径管理；配置语法由具体策略处理 |
+| `Configuration` | 持有配置文档、游标和节点，管理来源状态、捕获与嵌套路径；配置语法由具体策略处理 |
 | `Cursor` | 保存原文，顺序读取、窥视、回退，独立记录访问状态和逐行解析状态 |
 | `Line` | 不可变的源行，保留原始文本；构造时计算并缓存缩进和匹配文本 |
 | `Block` | 配置树节点，保存父子层次、源行范围和完整配置块原文 |
@@ -22,15 +22,21 @@
 | `Records` | 按调用方的身份键分析重复项，提供首条保留与无歧义投影 |
 | `Immutable` | 复制并冻结纯数据，与调用方的可变对象隔离 |
 | `Result` | 单个清单的 `status / records / issues` |
-| `ResultSet` | 同一回显产生的多个清单，各自保留 `Result` 和完整性 |
-| `CommandCatalog` | 一次声明命令、解析器与结果维度，校验并生成不可变索引 |
+| `Results` | 以 `by_dimension` 保存同一回显的具名结果，各维度独立保留 `Result` 和完整性 |
+| `Commands` | 一次声明命令、解析器与结果维度，校验并生成不可变索引 |
 | `Profile` | 组合命令与解析器，按型号覆盖策略，共享命令只解析一次 |
 | `Registry` | 由业务模块声明支持的平台和别名，选择对应 `Profile` |
 
-公共库不导入具体厂商，也不维护任何命令正则、设备会话或数据库投影。业务模块按职责复用公共抽象；VXLAN、Wireless 使用命令注册表，Baseline 直接从配置文本进入 `ConfigurationParser`。
+公共库不导入具体厂商，也不维护任何命令正则、设备会话或数据库投影。业务模块按职责复用公共抽象；VXLAN、Wireless 使用命令注册表，Baseline 直接从配置文本进入 `Configuration`。
 
-`Profile#queries(names)` 生成冻结的命令到维度计划，保留选择顺序并合并共享命令，支持同一维度的多条脚本。
-Result 的记录和诊断是防御性复制后的不可变数据；通过 `with(...)` 替换，不能原地修改。
+`Profile#queries(names)` 生成冻结的命令到维度计划，保留选择顺序并合并共享命令，支持同一维度的多条脚本。`parse_many` 选择覆盖全部维度的命令后直接查找解析器，型号覆盖仍优先；不重复扫描同一维度的命令列表，也不缓存可能被动态扩展替换的命令表。
+
+`Results#by_dimension` 是不带默认值或默认回调的普通冻结 Hash。未声明维度的下标读取返回 nil，`fetch` 抛出 KeyError，不能由调用方 Hash 的默认规则伪造解析证据。
+Result 的记录和诊断必须为 Hash 数组，是防御性复制后的不可变数据；通过 `with(...)` 替换，不能原地修改。文档在词法分析完成后也复制并深度冻结诊断，避免分类器保留的引用修改已有证据。
+
+`Immutable` 接受普通 Hash、Array、String、Symbol、nil、布尔值及内建 Integer、Float、Rational、Complex。Complex 的分量须满足同一规则；不接受自定义 Numeric 对象，即使其外层已冻结。Float 的非有限值仍保留，是否允许由具体字段语义决定。
+
+配置块的子节点必须属于同一游标、位于父范围内并按来源顺序排列，不可重复或重叠。完整性查询直接读取当前行状态，遇到未解决行立即返回；不会缓存可能过时的完整性结论。`benchmark/completeness.rb` 独立测量该查询，不代表端到端设备解析性能。
 具体兼容边界见 [模块架构](https://github.com/gatework/motor/blob/main/backend/vendor/ARCHITECTURE.md)。
 
 ```text
@@ -42,14 +48,14 @@ vendor/
     block.rb
     capture.rb
     document.rb
-    configuration_parser.rb
+    configuration.rb
     input.rb
     values.rb
     records.rb
     immutable.rb
     result.rb
-    result_set.rb
-    command_catalog.rb
+    results.rb
+    commands.rb
     profile.rb
     registry.rb
   vxlan/lib/vxlan/
@@ -58,6 +64,7 @@ vendor/
       profile.rb
       parser.rb
       configuration.rb                    # 特性、模板与网段事实归约
+      document.rb                         # 配置来源文档
       evpn_l2route.rb
       parsers/show_*.rb                    # 12 条 NX-OS 命令
   wireless/lib/wireless/
@@ -68,10 +75,10 @@ vendor/
       parser.rb
       command_output.rb                   # 配置与运行命令共用输入边界
       configuration.rb                    # 实体身份、归属与认证类型
-      verbose_parser.rb
-      session_parser.rb
-      authentication_parser.rb
-      parsers/display_*.rb                 # 8 条 H3C 命令
+      document.rb                         # 配置来源文档
+      record_parser.rb                    # 标签字段与记录分组
+      authentication.rb                   # 认证字段与身份定义
+      parsers/display_*.rb                 # 10 条 H3C 命令
   baseline/lib/baseline/
     document.rb                           # Baseline 自身的 banner 和提示行分类
     facts.rb                              # 跨命令的事实归约，不依赖解析游标
@@ -83,17 +90,18 @@ classDiagram
     CtxParser <|-- NxosParser
     CtxParser <|-- H3cParser
     NxosParser <|-- ShowIpOspfNeighbors
-    H3cParser <|-- DisplayCurrentConfiguration
-    H3cParser <|-- VerboseParser
-    VerboseParser <|-- DisplayWlanApAllVerbose
-    VerboseParser <|-- SessionParser
+    H3cParser <|-- RecordParser
+    RecordParser <|-- DisplayWlanApAllVerbose
+    RecordParser <|-- DisplayWlanClientVerbose
+    RecordParser <|-- DisplayDot1xConnection
+    Authentication <.. DisplayDot1xConnection : includes field definitions
     CtxParserProfile <|-- NxosProfile
     CtxParserProfile <|-- H3cProfile
     Registry --> CtxParserProfile : selects
     CtxParserProfile --> CtxParser : composes
     CtxParser --> Result : returns
-    CtxParser <|-- ConfigurationParser
-    CtxParser --> Cursor : owns per parse
+    CtxParser <|-- Configuration
+    Configuration --> Cursor : owns per parse
     Cursor --> Line : reads and tracks
     Cursor --> Capture : records
     Capture --> Block : source
@@ -101,13 +109,13 @@ classDiagram
     Document --> Cursor : owns
     Document --> Block : builds
     BaselineDocument --|> Document : line classification
-    BaselineParser --|> ConfigurationParser : analyze and capture
+    BaselineParser --|> Configuration : analyze and capture
     BaselineParser --> BaselineFacts : normalized observations
-    ShowRunningConfig --|> ConfigurationParser
-    DisplayCurrentConfiguration --|> ConfigurationParser
-    ConfigurationParser --> Capture : records scopes
-    DisplayWlanApAllVerbose --> ResultSet : returns AP and radio results
-    ResultSet --> Result : contains
+    ShowRunningConfig --|> Configuration
+    DisplayCurrentConfiguration --|> Configuration
+    Configuration --> Capture : records scopes
+    DisplayWlanApAllVerbose --> Results : returns AP and radio results
+    Results --> Result : contains
 ```
 
 ## 调用
@@ -137,7 +145,7 @@ results = h3c.parse_many(%i[access_points radios], ap_output, complete: true)
 results.fetch(:access_points).records
 results.fetch(:radios).records
 
-# 直接调用共享命令时，返回 ResultSet。
+# 直接调用共享命令时，返回 Results。
 parsed = Wireless::H3c::Parsers::DisplayWlanApAllVerbose.parse(ap_output, complete: true)
 parsed.fetch(:access_points).complete?
 parsed.fetch(:radios).issues
@@ -215,7 +223,7 @@ VXLAN、Wireless 和 Baseline 使用同一套输入与结构能力；各模块
 ```ruby
 CtxParser::Input.text(raw, encoding: :utf8, newlines: :lf)
 CtxParser::Values.integer("4094", min: 1, max: 4094)
-CtxParser::Values.mac("aabb.ccdd.eeff") # => "aa:bb:cc:dd:ee:ff"
+CtxParser::Values.mac_address("aabb.ccdd.eeff") # => "aa:bb:cc:dd:ee:ff"
 
 rows = CtxParser::Records.new(records, identity: [ :name ])
 rows.first_occurrences
@@ -229,24 +237,28 @@ snapshot = CtxParser::Immutable.copy({ "facts" => [ "ssh" ] })
 
 ## 新厂商、型号和格式
 
+`Values.integer` 只接受非负 Integer、完整十进制文本或表示缺失的 nil。`min` / `max` 仅接受 Integer 或 nil，且上限不得小于下限；即使原始值缺失，也校验选项。MAC 的四位分组格式必须一致使用点号或连字符，不混用分隔符。
+
 新增厂商时，在所属业务模块下建立平台目录、具体命令类和 `Profile`，加入该模块的 `ParserRegistry`。无需修改公共库或其他厂商的解析代码。
 
-每个平台通过普通 Ruby 数据声明一份 `CATALOG`，命令字符串只出现一次。相同回显的多个视图放在同一条声明中：
+每个平台通过普通 Ruby 数据声明一份 `DECLARATIONS`，命令字符串只出现一次。相同回显的多个视图放在同一条声明中：
 
 ```ruby
-CATALOG = CtxParser::CommandCatalog.new([
+DECLARATIONS = CtxParser::Commands.new([
   { dimensions: %i[access_points radios], command: "display wlan ap all verbose",
     parser: Parsers::DisplayWlanApAllVerbose },
   { dimensions: [ :clients ], command: "display wlan client verbose",
     parser: Parsers::DisplayWlanClientVerbose }
 ])
-COMMANDS = CATALOG.commands
-PARSERS = CATALOG.parsers
+COMMANDS = DECLARATIONS.by_dimension
+PARSERS = DECLARATIONS.parsers
 ```
 
-`CommandCatalog` 在构造时拒绝空声明、重复命令或维度、含控制字符的命令，以及非 `Parser` 子类。目录复制并冻结声明数据，不冻结解析器类或调用方的原始数组。由此派生的 `COMMANDS`（维度到命令）和 `PARSERS`（命令到策略）保持原有查询接口；已有自定义 Profile 仍可使用这两个映射。
+`Registry` 的平台和别名声明必须为 Hash，归一化名称冲突、不存在的别名目标及别名链均拒绝，配置错误统一在构造边界抛出 ArgumentError。
+
+`Commands` 在构造时拒绝空声明、重复命令或维度、含控制字符的命令，以及非 `Parser` 子类。声明数据由本实例复制并持有，命令索引在构建时追加、完成后冻结，避免每次追加复制已有列表；不冻结解析器类或调用方的原始数组。`benchmark/commands.rb` 测量构建和派发成本，保留命令顺序及结果校验。由此派生的 `COMMANDS`（维度到命令）和 `PARSERS`（命令到策略）保持原有查询接口；已有自定义 Profile 仍可使用这两个映射。
 
-具有共同语法的命令可复用平台基类；特有字段、表头、身份与总数规则留在对应命令中。会话、命令执行和证据持久化由采集器负责；`CommandCatalog` 不执行 I/O，也不引入动态类名查找或自动注册。
+具有共同语法的命令可复用平台基类；特有字段、表头、身份与总数规则留在对应命令中。会话、命令执行和证据持久化由采集器负责；`Commands` 不执行 I/O，也不引入动态类名查找或自动注册。
 
 型号差异用平台 `Profile::MODEL_PARSERS` 声明，形状为 `{ "规范化型号" => { "命令文本" => 专用解析器类 } }`。型号键使用去除首尾空格的小写完整型号，按精确名称匹配；专用解析器可继承已有命令类，仅覆盖有差异的方法。Profile 初始化时校验并复制所选型号的覆盖表：只允许覆盖已声明命令，策略必须继承 `Parser`；修改原表不会改变已创建的 Profile。未覆盖命令和无专用策略的型号使用该平台的公共格式，未知语法仍会产生不完整结果。采集器传入现有 `Motor::Device#model`，AP LLDP 使用 AP 自身型号。
 

data/lib/ctx_parser/block.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "cursor"
+
 module CtxParser
   # 配置节点覆盖整个子树，保留未知命令、空白及原始换行。
   class Block
@@ -10,11 +12,21 @@ module CtxParser
 
     # 冻结已校验的来源范围及其子配置块。
     def initialize(cursor:, header:, children:, last_index:)
-      unless cursor.lines[header.index].equal?(header) && last_index.is_a?(Integer) &&
+      unless cursor.is_a?(Cursor) && header.is_a?(Line) && cursor.lines[header.index].equal?(header) && last_index.is_a?(Integer) &&
           (header.index...cursor.size).cover?(last_index)
         raise ArgumentError, "Invalid source block range"
       end
 
+      previous_index = header.index
+      unless children.is_a?(Array) && children.all? do |child|
+          next false unless child.is_a?(Block) && child.cursor.equal?(cursor) &&
+            child.index > previous_index && child.last_index <= last_index && child.header.indent > header.indent
+
+          previous_index = child.last_index
+        end
+        raise ArgumentError, "Child blocks must be ordered within their parent source"
+      end
+
       @cursor, @header, @last_index = cursor, header, last_index
       @children = children.dup.freeze
       freeze
@@ -89,7 +101,7 @@ module CtxParser
     # 返回当前配置块各来源行的处理状态。
     def states = lines.map { |source| cursor.state(source.index) }.freeze
     # 要求块内所有来源行均已解析或明确忽略。
-    def complete? = states.all? { |state| Cursor::RESOLVED_STATES.include?(state) }
+    def complete? = (index..last_index).all? { |index| Cursor::RESOLVED_STATES.include?(cursor.state(index)) }
     # 序列化诊断元数据，不包含原始来源文本。
     def as_json(*) = { first_line: line, last_line: last_index + 1, children: children.size }
     # 展示对象身份与状态，避免泄露原始回显或凭据。

data/lib/ctx_parser/{command_catalog.rb → commands.rb}

@@ -4,21 +4,21 @@ require_relative "parser"
 
 module CtxParser
   # 每条命令仅声明一次，并派生不可变维度及解析器索引。
-  class CommandCatalog
-    attr_reader :entries, :commands, :parsers
+  class Commands
+    attr_reader :entries, :by_dimension, :parsers
 
     # 校验并冻结受支持的维度到命令声明。
     def initialize(entries, multi_command: false)
       unless entries.is_a?(Array) && entries.any?
-        raise ArgumentError, "Command catalog must contain declarations"
+        raise ArgumentError, "Commands must contain declarations"
       end
       raise ArgumentError, "Multi-command selection must be boolean" unless multi_command == true || multi_command == false
 
       @multi_command = multi_command
-      @commands, @parsers = {}, {}
+      @by_dimension, @parsers = {}, {}
       @entries = entries.map { |entry| register(entry) }.freeze
-      @commands.each_value { |value| value.freeze }
-      @commands.freeze
+      @by_dimension.each_value { |value| value.freeze }
+      @by_dimension.freeze
       @parsers.freeze
       freeze
     end
@@ -33,7 +33,7 @@ module CtxParser
 
       dimensions, command, parser = entry.values_at(:dimensions, :command, :parser)
       unless dimensions.is_a?(Array) && dimensions.any? && dimensions.all? { |name| name.is_a?(Symbol) && !name.empty? } &&
-          dimensions.uniq == dimensions && (@multi_command || dimensions.none? { |name| @commands.key?(name) })
+          dimensions.uniq == dimensions && (@multi_command || dimensions.none? { |name| @by_dimension.key?(name) })
         raise ArgumentError, "Command dimensions must be unique nonempty symbols"
       end
       unless command.is_a?(String) && !command.strip.empty? && !/[\x00-\x1f\x7f]/.match?(command)
@@ -45,7 +45,8 @@ module CtxParser
       command = command.dup.freeze
       dimensions = dimensions.dup.freeze
       dimensions.each do |name|
-        @commands[name] = @commands.key?(name) ? Array(@commands[name]) + [ command ] : command
+        # 索引数组由本实例持有，构建完成后统一冻结；追加不复制已有命令。
+        @by_dimension[name] = @by_dimension.key?(name) ? (Array(@by_dimension[name]) << command) : command
       end
       @parsers[command] = parser
       { dimensions: dimensions, command: command, parser: parser }.freeze

data/lib/ctx_parser/{configuration_parser.rb → configuration.rb}

@@ -1,17 +1,33 @@
 # frozen_string_literal: true
 
 require_relative "parser"
+require_relative "document"
 
 module CtxParser
   # 共享来源状态与作用域管理；具体解析器负责识别规则及诊断。
-  class ConfigurationParser < Parser
+  class Configuration < Parser
+    attr_reader :cursor, :blocks, :document
+
+    # 新解析开始即清空来源，参数校验失败也不暴露上一次配置。
+    def parse(text, complete: false)
+      @document, @cursor, @blocks = nil, nil, [].freeze
+      @source_path = []
+      @invalid_source = @source_error = nil
+      super
+    end
+
+    # 只展示配置来源元数据，不序列化原文。
+    def as_json(*) = super.merge(cursor: cursor&.as_json, blocks: Array(blocks).size)
+
     private
 
     # 为新的配置解析建立来源跟踪状态。
-    def read_configuration(...)
+    def read_configuration(text, comments: nil, boundaries: nil, document_class: Document)
       @source_path = []
       @invalid_source = @source_error = nil
-      super
+      @document = document_class.new(text, comments: comments, boundaries: boundaries)
+      @cursor, @blocks = document.cursor, document.roots
+      @blocks
     end
 
     # 仅在解释成功后标记来源行；嵌套转换失败归因到最内层来源。

data/lib/ctx_parser/document.rb

@@ -14,7 +14,7 @@ module CtxParser
       @comments, @boundaries, @issues = comments, boundaries, []
       @roots = Block.read(cursor) { |line| classify(line) }
       finish
-      @issues.freeze
+      @issues = Immutable.copy(@issues)
     end
 
     # 选择符合目标命令语法的根配置块。

data/lib/ctx_parser/immutable.rb

@@ -3,16 +3,81 @@
 module CtxParser
   # 复制并冻结普通数据，避免解析快照共享调用方可变状态。
   module Immutable
-    # 深度复制并冻结普通数据，拒绝可执行或不支持的对象。
+    COPYING = Object.new.freeze
+    private_constant :COPYING
+
+    # 同一容器只复制一次；循环数据不是普通值，须在越过快照边界前拒绝。
     def self.copy(value)
-      # 容器已冻结也可能持有可变子对象，仍须递归复制；冻结字符串可直接复用。
+      copy_value(value, {}.compare_by_identity, 0)
+    end
+
+    # 普通常量浅树沿用 Ruby 的映射；递归深度有界，深链交给显式后序栈。
+    def self.copy_value(value, copies, depth)
       case value
-      when Hash then value.to_h { |key, item| [ copy(key), copy(item) ] }.freeze
-      when Array then value.map { |item| copy(item) }.freeze
+      when Hash, Array
+        if (snapshot = copies[value])
+          raise ArgumentError, "Values must not contain cyclic data" if snapshot.equal?(COPYING)
+
+          return snapshot
+        end
+        return copy_deep(value, copies) if depth == 64
+
+        copies[value] = COPYING
+        copies[value] = if value.is_a?(Hash)
+          value.to_h { |key, item| [ copy_value(key, copies, depth + 1), copy_value(item, copies, depth + 1) ] }.freeze
+        else
+          value.map { |item| copy_value(item, copies, depth + 1) }.freeze
+        end
       when String then value.frozen? ? value : value.dup.freeze
-      when Symbol, Numeric, NilClass, TrueClass, FalseClass then value
+      when Symbol, Integer, Float, Rational, NilClass, TrueClass, FalseClass then value
+      when Complex
+        # Complex 自身冻结，但可包含调用方定义的可变 Numeric 分量。
+        copy_value(value.real, copies, depth + 1)
+        copy_value(value.imaginary, copies, depth + 1)
+        value
       else raise ArgumentError, "Values must contain plain data"
       end
     end
+    private_class_method :copy_value
+
+    # 容器缓存按来源身份查找，普通 Hash 的键仍沿用值相等语义。
+    def self.copy_deep(value, copies)
+      pending = [ [ value, false ] ]
+      until pending.empty?
+        source, finishing = pending.pop
+        if finishing
+          copies[source] = if source.is_a?(Hash)
+            source.to_h { |key, item| [ snapshot(key, copies), snapshot(item, copies) ] }.freeze
+          else
+            source.map { |item| snapshot(item, copies) }.freeze
+          end
+          next
+        end
+        if (existing = copies[source])
+          raise ArgumentError, "Values must not contain cyclic data" if existing.equal?(COPYING)
+
+          next
+        end
+
+        copies[source] = COPYING
+        pending << [ source, true ]
+        if source.is_a?(Hash)
+          source.each_pair do |key, item|
+            pending << [ item, false ] if container?(item)
+            pending << [ key, false ] if container?(key)
+          end
+        else
+          source.each { |item| pending << [ item, false ] if container?(item) }
+        end
+      end
+      copies.fetch(value)
+    end
+    private_class_method :copy_deep
+
+    def self.snapshot(value, copies) = container?(value) ? copies.fetch(value) : copy_value(value, copies, 0)
+    private_class_method :snapshot
+
+    def self.container?(value) = value.is_a?(Hash) || value.is_a?(Array)
+    private_class_method :container?
   end
 end

data/lib/ctx_parser/input.rb

@@ -19,13 +19,16 @@ module CtxParser
       raise EncodingError, "CLI output encoding is invalid" unless value.valid_encoding?
 
       value = value.encode(Encoding::UTF_8) if encoding == :transcode
-      raise ArgumentError, "CLI output contains a NUL byte" if !allow_nul && value.include?("\0")
+      # UTF-16/32 等编码不兼容 ASCII 字面量；仅在临时视图上检查逻辑字符。
+      logical = value.encoding.ascii_compatible? ? value : value.encode(Encoding::UTF_8)
+      raise ArgumentError, "CLI output contains a NUL byte" if !allow_nul && logical.include?("\0")
 
-      case newlines
-      when :lf then value.gsub(/\r\n?/, "\n")
-      when :delete_cr then value.delete("\r")
-      else value
+      normalized = case newlines
+      when :lf then logical.gsub(/\r\n?/, "\n")
+      when :delete_cr then logical.delete("\r")
+      else return value
       end
+      normalized.encoding == value.encoding ? normalized : normalized.encode(value.encoding)
     end
   end
 end

data/lib/ctx_parser/parser.rb

@@ -3,36 +3,26 @@
 module CtxParser
   # 提供公共命令解析契约；厂商语法、编码与完整性由子类负责。
   class Parser
-    attr_reader :cursor, :blocks, :document
-
     # 每次调用使用新实例解析，避免共享来源状态。
     def self.parse(text, complete: false)
       new.parse(text, complete: complete)
     end
 
-    # 校验输入及完整性，重置来源状态后执行命令解析器。
+    # 校验输入及完整性，随后执行命令解析器。
     def parse(text, complete: false)
-      @document, @cursor, @blocks = nil, nil, [].freeze
-      raise ArgumentError, "Runtime output must be text" unless text.is_a?(String)
+      raise ArgumentError, "Parser input must be text" unless text.is_a?(String)
       raise ArgumentError, "Completeness must be boolean" unless [ true, false ].include?(complete)
 
       parse_output(text, complete: complete)
     end
 
     # 序列化诊断元数据，不包含原始来源文本。
-    def as_json(*) = { parser: self.class.name, cursor: cursor&.as_json, blocks: Array(blocks).size }
+    def as_json(*) = { parser: self.class.name }
     # 展示对象身份与状态，避免泄露原始回显或凭据。
     def inspect = "#<#{self.class.name}>"
 
     private
 
-    # 每次解析创建私有游标与配置树；序列化结果不包含来源正文。
-    def read_configuration(text, comments: nil, boundaries: nil, document_class: Document)
-      @document = document_class.new(text, comments: comments, boundaries: boundaries)
-      @cursor, @blocks = document.cursor, document.roots
-      @blocks
-    end
-
     # 解释当前命令回显，保留不支持或格式错误的证据。
     def parse_output(text, complete:)
       raise NotImplementedError, "Command parsers must implement parse_output"
@@ -42,5 +32,4 @@ end
 
 # 在依赖可能触发 Rails 自动加载此命名空间前，先定义基础类。
 require_relative "result"
-require_relative "result_set"
-require_relative "document"
+require_relative "results"

data/lib/ctx_parser/profile.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "command_catalog"
+require_relative "commands"
 
 module CtxParser
   # 组合平台命令策略，仅覆盖已确认的型号差异。
@@ -16,7 +16,7 @@ module CtxParser
       raise ArgumentError, "Device model must be text" unless model.nil? || model.is_a?(String)
 
       @model = model&.strip&.downcase&.freeze
-      @model_parsers = model_parsers
+      @model_parsers = model_parser_overrides
     end
 
     # 返回当前平台策略声明的命令目录。
@@ -26,16 +26,16 @@ module CtxParser
     def parsers = self.class::PARSERS
 
     # 保留选择顺序并归组共享视图，不混用不同命令的正文。
-    def queries(names)
-      unless names.is_a?(Array) && names.uniq == names && (names - commands.keys).empty?
+    def queries(dimensions)
+      unless dimensions.is_a?(Array) && dimensions.uniq == dimensions && (dimensions - commands.keys).empty?
         raise ArgumentError, "Query dimensions must be unique supported names"
       end
 
-      plan = names.each_with_object({}) do |name, queries|
+      dimensions_by_command = dimensions.each_with_object({}) do |name, queries|
         commands_for(name).each { |command| (queries[command] ||= []) << name }
       end
-      plan.each_value(&:freeze)
-      plan.freeze
+      dimensions_by_command.each_value(&:freeze)
+      dimensions_by_command.freeze
     end
 
     # 单个维度可能需要多个独立回显；调用方必须分别保存正文。
@@ -69,21 +69,22 @@ module CtxParser
     end
 
     # AP、Radio 等共享视图仅解析一次，确保状态与数量证据一致。
-    def parse_many(names, text, complete: false, command: nil)
-      unless names.is_a?(Array) && names.any? && names.uniq == names
+    def parse_many(dimensions, text, complete: false, command: nil)
+      unless dimensions.is_a?(Array) && dimensions.any? && dimensions.uniq == dimensions
         raise ArgumentError, "Parser dimensions must be a nonempty unique array"
       end
-      query = select_command(names, command)
+      query = select_command(dimensions, command)
 
-      result = parser_for(names.first, command: query).parse(text, complete: complete)
-      names.to_h { |name| [ name, project_independently(name, result) ] }
+      # 查询已覆盖全部请求维度，无需再次遍历第一个维度的完整命令列表。
+      result = @model_parsers.fetch(query) { parsers.fetch(query) }.parse(text, complete: complete)
+      dimensions.to_h { |name| [ name, project_independently(name, result) ] }
     end
 
     private
 
     # 仅当存在唯一公共查询时允许推断；显式命令必须覆盖全部请求视图。
-    def select_command(names, selected)
-      candidates = names.map { |name| commands_for(name) }.reduce { |common, queries| common & queries }
+    def select_command(dimensions, selected)
+      candidates = dimensions.map { |name| commands_for(name) }.reduce { |common, queries| common & queries }
       unless selected.nil?
         raise ArgumentError, "Selected command does not provide all parser dimensions" unless candidates.include?(selected)
 
@@ -96,7 +97,7 @@ module CtxParser
     end
 
     # 采集前校验所选型号，并隔离后续修改对型号查找的影响。
-    def model_parsers
+    def model_parser_overrides
       declarations = self.class::MODEL_PARSERS
       raise ArgumentError, "Model parsers must be a hash" unless declarations.is_a?(Hash)
 
@@ -112,12 +113,12 @@ module CtxParser
 
     # 投影失败仅影响单个视图；命令选择及解析错误仍正常抛出。
     def project_independently(name, result)
-      return failed_projection(:invalid_parser_result) unless result.is_a?(Result) || result.is_a?(ResultSet)
+      return failed_projection(:invalid_parser_result) unless result.is_a?(Result) || result.is_a?(Results)
 
       projected = project(name, result)
       projected.is_a?(Result) ? projected : failed_projection(:invalid_parser_result)
     rescue KeyError
-      code = result.is_a?(ResultSet) && !result.results.key?(name) ? :missing_parser_view : :parser_projection_failed
+      code = result.is_a?(Results) && !result.key?(name) ? :missing_parser_view : :parser_projection_failed
       failed_projection(code)
     rescue StandardError
       failed_projection(:parser_projection_failed)
@@ -128,7 +129,7 @@ module CtxParser
 
     # 从共享命令结果中提取请求维度。
     def project(name, result)
-      result.is_a?(ResultSet) ? result.fetch(name) : result
+      result.is_a?(Results) ? result.fetch(name) : result
     end
   end
 end

data/lib/ctx_parser/records.rb

@@ -6,21 +6,21 @@ module CtxParser
     attr_reader :rows, :first_occurrences, :unambiguous, :duplicate_identity_count, :duplicate_row_count
 
     # 冻结筛选结果数组，记录值的所有权仍属于调用方。
-    def initialize(rows, identity: nil, &key)
+    def initialize(rows, identity: nil, &identity_key)
       unless rows.is_a?(Array) && rows.all? { |row| row.is_a?(Hash) }
         raise ArgumentError, "Records must be hashes"
       end
 
-      key ||= identity if identity.respond_to?(:call)
-      key ||= ->(row) { row.values_at(*identity) } if identity.is_a?(Array) && identity.any?
-      raise ArgumentError, "Identity must be a nonempty array or callable" unless key
+      identity_key ||= identity if identity.respond_to?(:call)
+      identity_key ||= ->(row) { row.values_at(*identity) } if identity.is_a?(Array) && identity.any?
+      raise ArgumentError, "Identity must be a nonempty array or callable" unless identity_key
 
       @rows = rows.dup.freeze
-      groups = @rows.group_by { |row| key.call(row) }.values
-      @first_occurrences = groups.map(&:first).freeze
-      @unambiguous = groups.filter_map { |group| group.first if group.one? }.freeze
-      @duplicate_identity_count = groups.count { |group| group.size > 1 }
-      @duplicate_row_count = @rows.size - groups.size
+      identity_groups = @rows.group_by { |row| identity_key.call(row) }.values
+      @first_occurrences = identity_groups.map(&:first).freeze
+      @unambiguous = identity_groups.filter_map { |group| group.first if group.one? }.freeze
+      @duplicate_identity_count = identity_groups.count { |group| group.size > 1 }
+      @duplicate_row_count = @rows.size - identity_groups.size
       freeze
     end
 

data/lib/ctx_parser/registry.rb

@@ -7,6 +7,10 @@ module CtxParser
   class Registry
     # 注册平台策略及其声明的别名。
     def initialize(profiles:, aliases: {})
+      unless profiles.is_a?(Hash) && aliases.is_a?(Hash)
+        raise ArgumentError, "Registry declarations must be hashes"
+      end
+
       @profiles = profiles.transform_keys { |key| platform_key(key) }.freeze
       @aliases = aliases.transform_keys { |key| platform_key(key) }.transform_values { |key| platform_key(key) }.freeze
       unless @profiles.size == profiles.size && @aliases.size == aliases.size &&

data/lib/ctx_parser/result.rb

@@ -9,6 +9,7 @@ module CtxParser
     def initialize(status:, records: [], issues: [])
       raise ArgumentError, "Invalid parser status" unless %i[complete partial failed unsupported].include?(status)
       raise ArgumentError, "Records must be hashes" unless records.is_a?(Array) && records.all? { |row| row.is_a?(Hash) }
+      raise ArgumentError, "Issues must be hashes" unless issues.is_a?(Array) && issues.all? { |issue| issue.is_a?(Hash) }
 
       super(status: status, records: Immutable.copy(records), issues: Immutable.copy(issues))
     end
@@ -18,5 +19,6 @@ module CtxParser
 
     # 展示对象身份与状态，避免泄露原始回显或凭据。
     def inspect = "#<#{self.class.name} status=#{status} records=#{records.size}>"
+    alias to_s inspect
   end
 end

data/lib/ctx_parser/results.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "result"
+
+module CtxParser
+  # 同一回显可产生多份清单，各自保留完整性与诊断。
+  Results = Data.define(:by_dimension) do
+    # 冻结具名章节结果，同时保留各章节的独立状态。
+    def initialize(by_dimension:)
+      unless by_dimension.is_a?(Hash) && by_dimension.any? &&
+          by_dimension.keys.all? { |name| name.is_a?(Symbol) && !name.empty? } &&
+          by_dimension.values.all? { |result| result.is_a?(Result) }
+        raise ArgumentError, "Results must map named dimensions to parser results"
+      end
+      # 普通映射不继承调用方的默认值或默认回调，缺失维度必须仍然缺失。
+      super(by_dimension: by_dimension.to_h { |name, result| [ name, result ] }.freeze)
+    end
+
+    # 返回必需的具名章节结果。
+    def fetch(name) = by_dimension.fetch(name)
+
+    # 只查询明确提供的维度，不把缺失结果当作空清单。
+    def key?(name) = by_dimension.key?(name)
+
+    # 判断所有已选事实是否都有完整证据支持。
+    def complete? = by_dimension.each_value.all?(&:complete?)
+
+    # 推导汇总状态，避免将证据缺失当作成功。
+    def status
+      return :complete if complete?
+      return :partial if by_dimension.each_value.any? { |result| %i[complete partial].include?(result.status) }
+
+      by_dimension.each_value.all? { |result| result.status == :unsupported } ? :unsupported : :failed
+    end
+
+    # 从全部章节结果汇总去重后的诊断。
+    def issues = by_dimension.each_value.flat_map(&:issues).uniq
+
+    # 展示对象身份与状态，避免泄露原始回显或凭据。
+    def inspect = "#<#{self.class.name} status=#{status} dimensions=#{by_dimension.keys.join(',')}>"
+    alias to_s inspect
+  end
+end

data/lib/ctx_parser/values.rb

@@ -11,19 +11,24 @@ module CtxParser
 
     # 解析十进制整数，并校验声明的边界。
     def integer(raw, min: 0, max: nil)
+      unless (min.nil? || min.is_a?(Integer)) && (max.nil? || max.is_a?(Integer)) && (min.nil? || max.nil? || min <= max)
+        raise ArgumentError, "Invalid integer limits"
+      end
       return if raw.nil?
-      raise ArgumentError, "Invalid decimal integer" unless /\A\d+\z/.match?(raw.to_s)
+      unless (raw.is_a?(String) || raw.is_a?(Integer)) && /\A\d+\z/.match?(raw.to_s)
+        raise ArgumentError, "Invalid decimal integer"
+      end
 
-      value = Integer(raw.to_s, 10)
+      value = raw.is_a?(Integer) ? raw : Integer(raw, 10)
       raise OutOfRange, "Integer out of range" if (min && value < min) || (max && value > max)
 
       value
     end
 
     # 归一化 MAC 地址，拒绝格式错误的输入。
-    def mac(raw)
+    def mac_address(raw)
       return if raw.nil?
-      unless /\A(?:[0-9a-f]{12}|(?:[0-9a-f]{4}[-.]){2}[0-9a-f]{4}|(?:[0-9a-f]{2}:){5}[0-9a-f]{2})\z/i.match?(raw)
+      unless raw.is_a?(String) && /\A(?:[0-9a-f]{12}|[0-9a-f]{4}([-.])[0-9a-f]{4}\1[0-9a-f]{4}|(?:[0-9a-f]{2}:){5}[0-9a-f]{2})\z/i.match?(raw)
         raise ArgumentError, "Invalid MAC address"
       end
 
@@ -31,29 +36,32 @@ module CtxParser
     end
 
     # 归一化主机地址，保留 IPv4 与 IPv6 语义。
-    def host(raw, allow_zone: false)
+    def ip_address(raw, allow_zone: false)
+      raise ArgumentError, "Zone permission must be boolean" unless [ true, false ].include?(allow_zone)
       return if raw.nil?
-      raise ArgumentError, "Invalid host address" if raw.include?("/") || (!allow_zone && raw.include?("%"))
+      raise ArgumentError, "Invalid IP address" unless raw.is_a?(String)
+      raise ArgumentError, "Invalid IP address" if raw.include?("/") || (!allow_zone && raw.include?("%"))
 
       IPAddr.new(raw).to_s
     end
 
     # 校验主机地址有效性，不让格式错误值继续传播。
-    def valid_host?(raw, allow_zone: false)
-      !host(raw, allow_zone: allow_zone).nil?
+    def ip_address?(raw, allow_zone: false)
+      !ip_address(raw, allow_zone: allow_zone).nil?
     rescue ArgumentError, IPAddr::Error
       false
     end
 
     # 统一校验网段与接口地址，仅接口投影保留主机位。
-    def ipv4_prefix(raw, host: false)
+    def ipv4_prefix(raw, preserve_host_bits: false)
+      raise ArgumentError, "Host-bit preservation must be boolean" unless [ true, false ].include?(preserve_host_bits)
       unless raw.is_a?(String) && raw.match?(%r{\A\d+(?:\.\d+){3}/\d+\z})
         raise ArgumentError, "IPv4 prefix required"
       end
       network = IPAddr.new(raw)
       raise ArgumentError, "IPv4 prefix required" unless network.ipv4?
 
-      host ? raw : "#{network}/#{network.prefix}"
+      preserve_host_bits ? raw : "#{network}/#{network.prefix}"
     end
   end
 end

data/lib/ctx_parser/version.rb

@@ -2,5 +2,5 @@
 
 module CtxParser
   # 公开包版本，供 RubyGems 元数据和运行时调用方共用。
-  VERSION = "0.1.1"
+  VERSION = "0.2.1"
 end

data/lib/ctx_parser.rb

@@ -8,10 +8,10 @@ end
 
 require_relative "ctx_parser/parser"
 if CtxParser.const_defined?(:Parser, false)
-  require_relative "ctx_parser/configuration_parser"
+  require_relative "ctx_parser/configuration"
   require_relative "ctx_parser/values"
   require_relative "ctx_parser/records"
-  require_relative "ctx_parser/command_catalog"
+  require_relative "ctx_parser/commands"
   require_relative "ctx_parser/profile"
   require_relative "ctx_parser/registry"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ctx_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Gatework contributors
@@ -37,7 +37,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Reusable configuration documents, command catalogs, platform profiles,
+description: Reusable configuration documents, command declarations, platform profiles,
   immutable results and parsing primitives for network automation.
 executables: []
 extensions: []
@@ -54,8 +54,8 @@ files:
 - lib/ctx_parser/banner.rb
 - lib/ctx_parser/block.rb
 - lib/ctx_parser/capture.rb
-- lib/ctx_parser/command_catalog.rb
-- lib/ctx_parser/configuration_parser.rb
+- lib/ctx_parser/commands.rb
+- lib/ctx_parser/configuration.rb
 - lib/ctx_parser/cursor.rb
 - lib/ctx_parser/document.rb
 - lib/ctx_parser/immutable.rb
@@ -66,7 +66,7 @@ files:
 - lib/ctx_parser/records.rb
 - lib/ctx_parser/registry.rb
 - lib/ctx_parser/result.rb
-- lib/ctx_parser/result_set.rb
+- lib/ctx_parser/results.rb
 - lib/ctx_parser/values.rb
 - lib/ctx_parser/version.rb
 homepage: https://github.com/gatework/ctx_parser

data/lib/ctx_parser/result_set.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "result"
-
-module CtxParser
-  # 同一回显可产生多份清单，各自保留完整性与诊断。
-  ResultSet = Data.define(:results) do
-    # 冻结具名章节结果，同时保留各章节的独立状态。
-    def initialize(results:)
-      unless results.is_a?(Hash) && results.any? && results.values.all? { |result| result.is_a?(Result) }
-        raise ArgumentError, "Result set must contain parser results"
-      end
-      super(results: results.dup.freeze)
-    end
-
-    # 返回必需的具名章节结果。
-    def fetch(name) = results.fetch(name)
-
-    # 判断所有已选事实是否都有完整证据支持。
-    def complete? = results.values.all?(&:complete?)
-
-    # 推导汇总状态，避免将证据缺失当作成功。
-    def status
-      return :complete if complete?
-      return :partial if results.values.any? { |result| %i[complete partial].include?(result.status) }
-
-      results.values.all? { |result| result.status == :unsupported } ? :unsupported : :failed
-    end
-
-    # 从全部章节结果汇总去重后的诊断。
-    def issues = results.values.flat_map(&:issues).uniq
-
-    # 展示对象身份与状态，避免泄露原始回显或凭据。
-    def inspect = "#<#{self.class.name} status=#{status} sections=#{results.keys.join(',')}>"
-  end
-end