wireless-rb 0.1.0 → 0.2.0

data/lib/wireless/h3c/parsers/display_current_configuration.rb

@@ -2,17 +2,21 @@
 
 require_relative "../command_output"
 require_relative "../configuration"
-require "ctx_parser/configuration_parser"
+require_relative "../document"
+require "ctx_parser/configuration"
 
 module Wireless
   module H3c
     module Parsers
       # 用缩进保留型号和 Radio 归属；相关命令不受支持时降低完整性。
-      class DisplayCurrentConfiguration < CtxParser::ConfigurationParser
+      class DisplayCurrentConfiguration < CtxParser::Configuration
         include CommandOutput
 
         private
 
+        # 配置由 Document 标记受损行，仍保留无关事实和原始来源。
+        def terminal_issue(_text) = nil
+
         # 声明当前命令解析器所需的换行归一化方式。
         def output_newlines = :preserve
 
@@ -20,7 +24,9 @@ module Wireless
         def parse_text(text, complete:)
           @configuration = H3c::Configuration.new
           @issues = []
-          read_configuration(text, comments: nil, boundaries: /\A(?:#|return)\z/)
+          @setting_assignments = {}.compare_by_identity
+          read_configuration(text, comments: nil, boundaries: /\A(?:#|return)\z/, document_class: Document)
+          @issues.concat(document.issues)
           recognized = cursor.lines.any? { |line| line.text == "return" }
           blocks.each { |block| recognized = parse_block(block) || recognized }
           @issues << { code: :missing_completeness_evidence } unless complete
@@ -43,14 +49,12 @@ module Wireless
           line = block.text
           selected = owner ? nested_scope(line, owner) : root_scope(line)
           if selected
-            scope(block, selected.path) do
-              block.children.each { |child| parse_block(child, selected) }
-              selected.finish
-            end
+            parse_scope(block, selected)
             true
           elsif !owner && (match = /\Asysname (\S+)\z/.match(line))
-            @configuration.data[:global_settings][:hostname] = match[1]
-            capture(block, match[1], [ :global_settings, :hostname ])
+            settings = @configuration.data[:global_settings]
+            assign_setting(settings, :hostname, match[1], block)
+            capture(block, settings[:hostname], [ :global_settings, :hostname ]) if settings.key?(:hostname)
             true
           elsif owner
             apply_block(block, owner)
@@ -68,9 +72,12 @@ module Wireless
           if (match = /\Awlan (ap-group|service-template|ap) (\S+)(?: (.+))?\z/i.match(line))
             kind = { "ap-group" => :ap_groups, "service-template" => :service_templates, "ap" => :access_points }.fetch(match[1].downcase)
             name, suffix = match[2], match[3]
+            if kind == :ap_groups && suffix && !/\Atype \S+\z/i.match?(suffix)
+              raise ArgumentError, "Invalid AP group type"
+            end
             raise ArgumentError, "Invalid service template" if kind == :service_templates && suffix
-            raise ArgumentError, "Missing AP model" if kind == :access_points && !suffix&.start_with?("model ")
-            @configuration.entity(kind, name, model: suffix&.delete_prefix("model "), type: suffix&.delete_prefix("type "))
+            raise ArgumentError, "Missing AP model" if kind == :access_points && !/\Amodel \S+\z/i.match?(suffix.to_s)
+            @configuration.entity(kind, name, model: suffix&.sub(/\Amodel /i, ""), type: suffix&.sub(/\Atype /i, ""))
           elsif (match = /\Awlan (global-configuration|virtual-ap-group(?: \S+)?|ap-license-group|vip-client-group)\z/i.match(line))
             key = match[1].tr("-", "_").split.first.to_sym
             @configuration.global(key, identity: line.split[2])
@@ -89,7 +96,7 @@ module Wireless
 
         # 标记已识别叶子语句，不将其嵌套未知语法提升到父对象。
         def apply_block(block, owner)
-          unless apply(owner, block.text, @configuration.data)
+          unless apply(owner, block, @configuration.data)
             unrecognized_block(block)
             return false
           end
@@ -108,134 +115,201 @@ module Wireless
 
         # 逐来源行记录不支持语法，并保留完整来源块。
         def unrecognized_block(block)
-          cursor.mark(block.index, state: :unsupported)
-          @issues << { code: :unrecognized_wireless_configuration, line: block.line }
-          block.children.each { |child| unrecognized_block(child) }
+          pending = [ block ]
+          until pending.empty?
+            current = pending.pop
+            cursor.mark(current.index, state: :unsupported)
+            @issues << { code: :unrecognized_wireless_configuration, line: current.line }
+            pending.concat(current.children.reverse)
+          end
+        end
+
+        # 无关配置可忽略，未知父级内的无线声明不能被当作不存在。
+        def ignore(block)
+          pending = [ block ]
+          until pending.empty?
+            current = pending.pop
+            if /\A(?:undo )?wlan\b/i.match?(current.text)
+              unrecognized_block(current)
+            else
+              cursor.mark(current.index, state: :ignored)
+              pending.concat(current.children.reverse)
+            end
+          end
+          nil
         end
 
         # 报告未在预期作用域消费的相关子语句。
         def unparsed_child(block) = unrecognized_block(block)
 
+        # 每个声明块独立检查单值；重复进入的顺序配置仍保留各自来源快照。
+        def parse_scope(block, owner)
+          previous_assignments = @setting_assignments
+          @setting_assignments = {}.compare_by_identity
+          scope(block, owner.path) do
+            block.children.each { |child| parse_block(child, owner) }
+            if owner.kind == :service_templates && @setting_assignments.values.any? { |fields| fields.values.any? { |entry| entry[:conflicted] } }
+              owner.record[:authentication_type] = nil
+            else
+              owner.finish
+            end
+            owner.record
+          end
+        ensure
+          @setting_assignments = previous_assignments
+        end
+
+        # 等价重复不改变完整性；同块冲突删除事实，并使原始来源和后续声明失效。
+        def assign_setting(record, key, value, block)
+          assign_settings(record, key, { key => value }, block)
+        end
+
+        # 一条命令的关联字段共享身份，冲突时整体排除，不能留下残缺派生标志。
+        def assign_settings(record, identity, values, block)
+          fields = (@setting_assignments[record] ||= {})
+          previous = fields[identity]
+          if previous && (previous[:conflicted] || previous[:value] != values)
+            (previous[:value].keys | values.keys).each { |key| record.delete(key) }
+            cursor.mark(previous[:block].index, state: :invalid)
+            cursor.mark(block.index, state: :invalid)
+            @issues << { code: :conflicting_configuration_value, line: block.line, first_line: previous[:block].line }
+            previous[:conflicted] = true
+          else
+            fields[identity] ||= { value: values, block: block }
+            record.merge!(values)
+          end
+        end
+
+        # 未声明的可选 VLAN 保持未知，已声明值须在设备 VLAN 范围内。
+        def configured_vlan(raw)
+          vlan = Fields.integer(raw, max: 4094)
+          raise ArgumentError, "Invalid configured VLAN" if vlan && vlan.zero?
+          vlan
+        end
+
         # 将已识别的无线设置应用到当前作用域记录。
-        def apply(scope, line, config)
+        def apply(scope, block, config)
+          line = block.text
           owner, kind, record = scope.record, scope.kind, scope.settings
           words = line.split
           enabled = !line.start_with?("undo ")
           case line
           when /\A(?:undo )?region-code-lock enable\z/
             return false unless kind == :global_configuration
-            record[:region_code_lock] = enabled
+            assign_setting(record, :region_code_lock, enabled, block)
           when /\Anas-id (\S+)\z/
             return false unless kind == :global_configuration
-            record[:nas_id] = Regexp.last_match(1)
+            assign_setting(record, :nas_id, Regexp.last_match(1), block)
           when /\A(?:undo )?rrop anti-bmc network (ipv4-and-ipv6-simple) enable\z/
             return false unless kind == :ap_groups
-            (record[:rrop_anti_bmc] ||= {})[:network] = { mode: Regexp.last_match(1), enabled: enabled }
+            assign_setting(record[:rrop_anti_bmc] ||= {}, :network, { mode: Regexp.last_match(1), enabled: enabled }, block)
           when /\Arrop anti-bmc default-action (deny|permit)\z/
             return false unless kind == :ap_groups
-            (record[:rrop_anti_bmc] ||= {})[:default_action] = Regexp.last_match(1)
+            assign_setting(record[:rrop_anti_bmc] ||= {}, :default_action, Regexp.last_match(1), block)
           when /\Aserial-id (\S+)\z/
             return false unless %i[access_points ap_groups].include?(kind)
-            kind == :ap_groups ? owner[:serial_ids] << words.last : record[:serial_id] = words.last
+            kind == :ap_groups ? owner[:serial_ids] << words.last : assign_setting(record, :serial_id, words.last, block)
           when /\Aap (\S+)\z/
             return false unless kind == :ap_groups
             owner[:ap_names] << words.last
           when /\Avlan (\d+)\z/
-            vlan = Fields.integer(words.last, max: 4094)
-            kind == :ap_groups ? owner[:vlan_ids] << vlan : owner[:vlan_id] = vlan
+            vlan = configured_vlan(words.last)
+            kind == :ap_groups ? owner[:vlan_ids] << vlan : assign_setting(owner, :vlan_id, vlan, block)
           when /\Assid (.+)\z/
             return false unless kind == :service_templates
-            owner[:ssid] = Regexp.last_match(1)
+            assign_setting(owner, :ssid, Regexp.last_match(1), block)
           when /\A(?:undo )?service-template enable\z/
             return false unless kind == :service_templates
-            owner[:enabled] = enabled
+            assign_setting(owner, :enabled, enabled, block)
           when /\Aservice-template (\S+)(?: vlan (\d+))?\z/
             return false unless kind == :radio
             name, vlan = Regexp.last_match.captures
-            binding = { name: name, vlan_id: Fields.integer(vlan, max: 4094) }
-            previous = record[:service_templates].find { |entry| entry[:name] == name }
-            raise ArgumentError, "Conflicting template binding" if previous && previous != binding
-            record[:service_templates] |= [ binding ]
+            @configuration.bind_template(record, name, configured_vlan(vlan))
           when /\Apreshared-key\s+.+\z/i
-            record[:has_preshared_key] = true
+            assign_setting(record, :has_preshared_key, true, block)
           when /\Aakm mode (.+)\z/
-            record[:akm_modes] = Regexp.last_match(1).downcase.gsub("802.1x", "dot1x").split
+            assign_setting(record, :akm_modes, Regexp.last_match(1).downcase.gsub("802.1x", "dot1x").split, block)
           when /\A(cipher-suite|security-ie) (.+)\z/
             key = words.first == "cipher-suite" ? :cipher_suites : :security_ies
-            record[key] = words.drop(1).map(&:downcase)
+            assign_setting(record, key, words.drop(1).map(&:downcase), block)
           when /\Aclient-security authentication-mode (.+)\z/
-            record[:client_security_authentication_mode] = Regexp.last_match(1).downcase
+            mode = Regexp.last_match(1).downcase
+            unless %w[dot1x mac mac-and-dot1x dot1x-then-mac mac-then-dot1x oui-then-dot1x].include?(mode)
+              raise ArgumentError, "Invalid client authentication mode"
+            end
+            assign_setting(record, :client_security_authentication_mode, mode, block)
           when /\Aclient-security (ignore-authentication|ignore-authorization)\z/
-            record[words.last.tr("-", "_").to_sym] = true
+            assign_setting(record, words.last.tr("-", "_").to_sym, true, block)
           when /\A(dot1x|mac-authentication) domain (\S+)\z/
-            record["#{words.first.tr('-', '_')}_domain".to_sym] = words.last
+            assign_setting(record, "#{words.first.tr('-', '_')}_domain".to_sym, words.last, block)
           when /\Aportal (enable method|domain|bas-ip|apply web-server|apply mac-trigger-server) (\S+)\z/
             key, value = Regexp.last_match.captures
             # 仅保留 Portal 是否存在；URL 与凭据不属于无线清单契约。
-            (record[:portal] ||= {})[key.tr(" -", "__").to_sym] = value.include?("://") ? true : value
+            assign_setting(record[:portal] ||= {}, key.tr(" -", "__").to_sym, value.include?("://") ? true : value, block)
           when /\A(?:undo )?(dot1x|mac-authentication)\z/
-            record["#{Regexp.last_match(1).tr('-', '_')}_enabled".to_sym] = enabled
+            assign_setting(record, "#{Regexp.last_match(1).tr('-', '_')}_enabled".to_sym, enabled, block)
           when /\Adot1x authentication-method (chap|eap|pap)\z/
-            record[:dot1x_authentication_method] = Regexp.last_match(1)
+            assign_setting(record, :dot1x_authentication_method, Regexp.last_match(1), block)
           when /\Amac-authentication user-name-format fixed(?: account \S+)?(?: password (simple|cipher) \S+)?\z/
             # 固定账号的明文和密文均不进入普通事实或捕获快照。
             storage = Regexp.last_match(1)
-            record[:mac_authentication_user_name_format] = "fixed"
-            record[:mac_authentication_has_password] = !storage.nil?
+            assign_settings(record, :mac_username_setting,
+              { mac_authentication_user_name_format: "fixed", mac_authentication_has_password: !storage.nil? }, block)
           when /\Amac-authentication user-name-format (mac-address(?: (?:with-hyphen|without-hyphen))?(?: (?:lowercase|uppercase))?)\z/
-            record[:mac_authentication_user_name_format] = Regexp.last_match(1)
-            record.delete(:mac_authentication_has_password)
+            assign_settings(record, :mac_username_setting, { mac_authentication_user_name_format: Regexp.last_match(1) }, block)
           when /\Adot1x timer (supp-timeout|tx-period) (\d+)\z/
-            (record[:dot1x_timers] ||= {})[words[2].tr("-", "_").to_sym] = Fields.integer(words.last)
+            assign_setting(record[:dot1x_timers] ||= {}, words[2].tr("-", "_").to_sym, Fields.integer(words.last), block)
           when /\Awlan (?:client-security )?static-(black|white)list mac-address (\S+)(?: (.+))?\z/
             kind, mac, reason = Regexp.last_match.captures
-            config[kind == "black" ? :blacklist : :whitelist] << { mac_address: Fields.mac(mac), reason: reason }
+            config[kind == "black" ? :blacklist : :whitelist] << { mac_address: Fields.mac_address(mac), reason: reason }
           when /\A(?:undo )?(?:wlan )?(auto-ap|auto-persistent|band-navigation|client inspect|radio-load-balance band-navigation) enable\z/
-            record[Regexp.last_match(1).tr(" -", "__").to_sym] = enabled
+            assign_setting(record, Regexp.last_match(1).tr(" -", "__").to_sym, enabled, block)
           when /\A(?:undo )?(beacon ssid-hide|bss transition-management enable)\z/
-            record[line.include?("ssid-hide") ? :ssid_hidden : :btm_enabled] = enabled
+            assign_setting(record, line.include?("ssid-hide") ? :ssid_hidden : :btm_enabled, enabled, block)
           when /\A(client keep-alive|client-rate-limit|firmware-upgrade|radio) (enable|disable)\z/
             key = { "client keep-alive" => :client_keep_alive, "client-rate-limit" => :client_rate_limit_enabled,
               "firmware-upgrade" => :firmware_upgrade, "radio" => :enabled }.fetch(Regexp.last_match(1))
-            record[key] = words.last == "enable"
+            assign_setting(record, key, words.last == "enable", block)
           when /\A(client keep-alive interval|client max-count|client cache aging-time|bss transition-management disassociation forced timer|statistics-interval|priority|dot1x retry|wlan tcp mss) (\d+)\z/
             key = { "client keep-alive interval" => :client_keep_alive_interval, "client max-count" => :client_max_count,
               "client cache aging-time" => :client_cache_aging_time, "bss transition-management disassociation forced timer" => :btm_disassociation_timer,
               "statistics-interval" => :statistics_interval, "priority" => :priority, "dot1x retry" => :dot1x_retry, "wlan tcp mss" => :tcp_mss }.fetch(Regexp.last_match(1))
-            record[key] = Fields.integer(words.last)
+            assign_setting(record, key, Fields.integer(words.last), block)
           when /\A(?:description|map-configuration) (.+)\z/
-            record[words.first.tr("-", "_").to_sym] = words.drop(1).join(" ")
-          when /\Abackup-ac ip (\S+)\z/ then record[:backup_ac_ip] = Fields.ip(words.last)
-          when /\Achannel band-width (.+)\z/ then record[:channel_bandwidth] = Regexp.last_match(1)
-          when /\Achannel auto unlock\z/ then record.merge!(channel: "auto", channel_number: nil, channel_unlocked: true)
+            assign_setting(record, words.first.tr("-", "_").to_sym, words.drop(1).join(" "), block)
+          when /\Abackup-ac ip (\S+)\z/ then assign_setting(record, :backup_ac_ip, Fields.ip_address(words.last), block)
+          when /\Achannel band-width (.+)\z/ then assign_setting(record, :channel_bandwidth, Regexp.last_match(1), block)
+          when /\Achannel auto unlock\z/
+            assign_settings(record, :channel_setting, { channel: "auto", channel_number: nil, channel_unlocked: true }, block)
           when /\Achannel (.+)\z/
-            record[:channel] = Regexp.last_match(1)
-            record[:channel_number] = Fields.channel(record[:channel])
-          when /\Amax-power (\d+(?:\.\d+)?)\z/ then record[:max_power] = Fields.number(words.last)
+            channel = Regexp.last_match(1)
+            channel_number = Fields.channel(channel)
+            assign_settings(record, :channel_setting, { channel: channel, channel_number: channel_number }, block)
+          when /\Amax-power (\d+(?:\.\d+)?)\z/ then assign_setting(record, :max_power, Fields.number(words.last), block)
           when /\Aclient-rate-limit (inbound|outbound) mode (\S+) cir (\d+)\z/
-            (record[:client_rate_limit] ||= {})[words[1].to_sym] = { mode: words[3], cir_bps: Fields.integer(words.last) * 1000 }
+            assign_setting(record[:client_rate_limit] ||= {}, words[1].to_sym, { mode: words[3], cir_bps: Fields.integer(words.last) * 1000 }, block)
           when /\Arate (mandatory|supported|disabled|multicast) (.+)\z/
-            (record[:rates] ||= {})[words[1].to_sym] = words[1] == "multicast" ? words.drop(2).join(" ") : words.drop(2).map { |word| Fields.number(word) }
+            assign_setting(record[:rates] ||= {}, words[1].to_sym, words[1] == "multicast" ? words.drop(2).join(" ") : words.drop(2).map { |word| Fields.number(word) }, block)
           when /\Aoption client (reject|reconnect) enable rssi (-?\d+(?:\.\d+)?)\z/
-            (record[:client_options] ||= {})[words[2].to_sym] = Fields.number(words.last)
+            assign_setting(record[:client_options] ||= {}, words[2].to_sym, Fields.number(words.last), block)
           when /\Asacp anti-sticky enable(?: rssi (-?\d+(?:\.\d+)?))? interval (\d+)\z/
             signal, interval = Regexp.last_match.captures
-            record[:anti_sticky] = { enabled: true, rssi: Fields.number(signal), interval: Fields.integer(interval) }
+            assign_setting(record, :anti_sticky, { enabled: true, rssi: Fields.number(signal), interval: Fields.integer(interval) }, block)
           when /\Apacket-filter name (\S+) (inbound|outbound)\z/
-            (record[:packet_filters] ||= {})[words.last.to_sym] = words[2]
+            assign_setting(record[:packet_filters] ||= {}, words.last.to_sym, words[2], block)
           when /\A(?:client forwarding-location|wlan image-load filepath|wlan fast-forwarding mode|led-mode) (\S+)\z/
             key = { "client" => :forwarding_location, "wlan image-load" => :image_load_filepath,
               "wlan fast-forwarding" => :fast_forwarding_mode, "led-mode" => :led_mode }
-            record[key.fetch(words.first == "wlan" ? words.take(2).join(" ") : words.first)] = words.last
+            assign_setting(record, key.fetch(words.first == "wlan" ? words.take(2).join(" ") : words.first), words.last, block)
           when /\A(local|member) ip (\S+)\z/
-            words.first == "local" ? record[:local_ip] = Fields.ip(words.last) : (record[:member_ips] ||= []) << Fields.ip(words.last)
-          when /\Aclient-mac (\S+)\z/ then (record[:mac_addresses] ||= []) << Fields.mac(words.last)
-          when "wlan tunnel-preempt enable" then record[:tunnel_preempt] = true
-          when "broadcast-probe reply disable" then record[:broadcast_probe_reply] = false
-          when "radar-detect disable" then record[:radar_detect_disabled] = true
-          when "calibrate-channel self-decisive enable all" then record[:calibrate_channel] = true
-          when "calibrate-power self-decisive enable all" then record[:calibrate_power] = true
-          when "ap-license-synchronization enable" then record[:license_synchronization] = true
+            words.first == "local" ? assign_setting(record, :local_ip, Fields.ip_address(words.last), block) : (record[:member_ips] ||= []) << Fields.ip_address(words.last)
+          when /\Aclient-mac (\S+)\z/ then (record[:mac_addresses] ||= []) << Fields.mac_address(words.last)
+          when "wlan tunnel-preempt enable" then assign_setting(record, :tunnel_preempt, true, block)
+          when "broadcast-probe reply disable" then assign_setting(record, :broadcast_probe_reply, false, block)
+          when "radar-detect disable" then assign_setting(record, :radar_detect_disabled, true, block)
+          when "calibrate-channel self-decisive enable all" then assign_setting(record, :calibrate_channel, true, block)
+          when "calibrate-power self-decisive enable all" then assign_setting(record, :calibrate_power, true, block)
+          when "ap-license-synchronization enable" then assign_setting(record, :license_synchronization, true, block)
           else return false
           end
           true

data/lib/wireless/h3c/parsers/display_dot1x_connection.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
-require_relative "../authentication_parser"
+require_relative "../record_parser"
+require_relative "../authentication"
 
 module Wireless
   module H3c
     module Parsers
       # 解析 display dot1x connection 报告的会话。
-      class DisplayDot1xConnection < AuthenticationParser
+      class DisplayDot1xConnection < RecordParser
+        include Authentication
       end
     end
   end

data/lib/wireless/h3c/parsers/display_lldp_neighbor_information_verbose.rb

@@ -23,8 +23,25 @@ module Wireless
           current = nil
           local = nil
           description_indent = nil
+          description = description_line = nil
+          store_description = lambda do
+            if description
+              assign_value(current[:details] ||= {}, :system_description, description, issues, description_line)
+              description = description_indent = nil
+            end
+          end
+          continuation_lines = {}
           flush = lambda do
             if current && current.values_at(:local_interface, :remote_chassis_id, :remote_interface).all? { |value| value && !value.strip.empty? }
+              if /mac address/i.match?(current.dig(:details, :chassis_type).to_s)
+                begin
+                  current[:remote_chassis_id] = Fields.mac_address(current[:remote_chassis_id])
+                rescue ArgumentError
+                  issues << { code: :invalid_chassis_id }
+                  current = nil
+                  next
+                end
+              end
               records << current
             elsif current
               issues << { code: :incomplete_neighbor }
@@ -35,10 +52,11 @@ module Wireless
             row = line.strip
             next if row.empty? || /\A[-=]+\z/.match?(row)
             if description_indent && line[/\A\s*/].size > description_indent
-              current[:details][:system_description] += "\n#{row}"
+              description << "\n" << row
+              continuation_lines[index + 1] = true
               next
             end
-            description_indent = nil
+            store_description.call
             if (match = /\ALLDP neighbor-information of port \d+\[(.+?)\]\s*:?\z/i.match(row))
               flush.call
               local = match[1]
@@ -52,27 +70,33 @@ module Wireless
               label = label.strip.downcase
               current ||= { local_interface: local }
               case label
-              when "chassis id" then current[:remote_chassis_id] = raw.downcase
-              when "port id" then current[:remote_interface] = raw
-              when "system name" then current[:remote_name] = Fields.value(raw)
+              when "chassis id" then assign_value(current, :remote_chassis_id, raw, issues, index + 1)
+              when "port id" then assign_value(current, :remote_interface, raw, issues, index + 1)
+              when "system name" then assign_value(current, :remote_name, Fields.value(raw), issues, index + 1)
               when "management address"
                 begin
-                  current[:management_address] = Fields.ip(Fields.value(raw))
+                  assign_value(current, :management_address, Fields.ip_address(Fields.value(raw)), issues, index + 1)
                 rescue IPAddr::InvalidAddressError, ArgumentError
                   issues << { code: :invalid_management_address, line: index + 1 }
                 end
-              when "port vlan id(pvid)" then (current[:details] ||= {})[:port_vlan_id] = raw
+              when "port vlan id(pvid)" then assign_value(current[:details] ||= {}, :port_vlan_id, raw, issues, index + 1)
               when *DETAILS
-                (current[:details] ||= {})[label.tr(" ", "_").to_sym] = raw
-                description_indent = line[/\A\s*/].size if label == "system description"
+                if label == "system description"
+                  description = raw.dup
+                  description_line = index + 1
+                  description_indent = line[/\A\s*/].size
+                else
+                  assign_value(current[:details] ||= {}, label.tr(" ", "_").to_sym, raw, issues, index + 1)
+                end
               else issues << { code: :unrecognized_field, line: index + 1 }
               end
             else
               issues << { code: :unrecognized_line, line: index + 1 }
             end
           end
+          store_description.call
           flush.call
-          total = /(?:total(?: (?:LLDP )?neighbors)?|number of neighbors)[^\n:]*:\s*(\d+)\s*$/i.match(text)&.[](1)&.to_i
+          total = reported_total(text, noun: "(?:LLDP )?neighbors", issues: issues, continuation_lines: continuation_lines)
           total ||= 0 if /\ANo (?:LLDP )?neighbors\s*$/i.match?(text.strip)
           Fields.result(records, issues: issues, complete: complete, total: total,
             identity: %i[local_interface remote_chassis_id remote_interface])

data/lib/wireless/h3c/parsers/display_mac_authentication_connection.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
-require_relative "../authentication_parser"
+require_relative "../record_parser"
+require_relative "../authentication"
 
 module Wireless
   module H3c
     module Parsers
       # 解析 display mac-authentication connection 报告的会话。
-      class DisplayMacAuthenticationConnection < AuthenticationParser
+      class DisplayMacAuthenticationConnection < RecordParser
+        include Authentication
       end
     end
   end

data/lib/wireless/h3c/parsers/display_wlan_ap_all_verbose.rb

@@ -1,20 +1,23 @@
 # frozen_string_literal: true
 
-require_relative "../verbose_parser"
+require_relative "../record_parser"
 
 module Wireless
   module H3c
     module Parsers
       # 单条回显同时包含 AP 清单及其嵌套 Radio 清单。
-      class DisplayWlanApAllVerbose < VerboseParser
+      class DisplayWlanApAllVerbose < RecordParser
         AP_FIELDS = { "ap id" => :ap_id, "ap group name" => :group_name, "state" => :operational_status,
           "model" => :model, "mac address" => :mac_address, "ip address" => :management_ip,
           "serial id" => :serial, "s/w version" => :os_version, "client count" => :client_count,
-          "number of clients" => :client_count, "online clients" => :client_count, "online time" => :uptime_seconds }.freeze
+          "number of clients" => :client_count, "online clients" => :client_count, "online time" => :online_seconds, "system uptime" => :uptime_seconds }.freeze
         RADIO_FIELDS = { "admin state" => :admin_status, "state" => :admin_status, "radio type" => :protocol,
           "type" => :protocol, "channel" => :channel, "channel usage(%)" => :utilization,
           "channel usage" => :utilization, "noise floor" => :noise_dbm, "channel bandwidth" => :channel_width,
-          "operating bandwidth" => :channel_width }.freeze
+          "operating bandwidth" => :channel_width, "channel band-width" => :channel_width }.freeze
+        RADIO_SECTIONS = { "operational vht-mcs set" => :vht_mcs, "operational ht mcs set" => :ht_mcs,
+          "operational he-mcs set" => :he_mcs, "operational rate" => :operational_rates }.freeze
+        SECTION_FIELDS = %w[mandatory supported multicast disabled].freeze
         AP_DETAILS = [ "backup type", "ready-for-switchover", "system uptime", "region code", "region code lock",
           "udp control port number", "udp data port number", "h/w version", "boot version", "usb state", "power level",
           "power info", "poe status", "description", "priority", "echo interval", "echo count", "keepalive interval",
@@ -25,7 +28,7 @@ module Wireless
           "connection count", "backup ipv4", "backup ipv6", "ctrl-tunnel encryption", "ctrl-tunnel encryption state",
           "data-tunnel encryption", "data-tunnel encryption state", "led mode", "remote configuration", "energysaving level",
           "ap type", "map file", "forwarding mode", "ble mode", "capwap data-tunnel status" ].freeze
-        RADIO_DETAILS = [ "basic bssid", "bssid", "antenna type", "client dot11ac-only", "client dot11n-only",
+        RADIO_DETAILS = [ "basic bssid", "base bssid", "bssid", "antenna type", "client dot11ac-only", "client dot11n-only",
           "secondary channel offset", "secondary channel mode", "short gi for 20mhz", "short gi for 40mhz",
           "short gi for 80mhz", "short gi for 160mhz", "mimo", "green-energy-management", "a-msdu", "a-mpdu", "ldpc", "stbc",
           "max power", "operational rate", "distance", "ani", "fragmentation threshold", "beacon interval", "protection threshold",
@@ -40,16 +43,35 @@ module Wireless
         # 解释当前命令记录，保留不完整行诊断。
         def parse_text(text, complete:)
           access_points, radios, issues = [], [], []
+          aps_with_radio_evidence = {}.compare_by_identity
           ap = radio = nil
-          tokens(text, issues).each do |label, raw, line|
+          section = nil
+          section_indent = nil
+          read_fields(text, issues).each do |label, raw, line, indent|
             if label == "ap name"
               ap = { name: raw }
               access_points << ap
               radio = nil
+              section = nil
             elsif (match = /\Aradio (\d+)\z/.match(label))
               radio = { ap_name: ap&.fetch(:name), radio_id: match[1] }
               radios << radio
+              aps_with_radio_evidence[ap] = true if ap
+              section = nil
             else
+              if radio && RADIO_SECTIONS.key?(label)
+                section = RADIO_SECTIONS.fetch(label)
+                section_indent = indent
+                # 空标题本身不属于测量；其子标签在相应速率或 MCS 集合内拥有身份。
+                assign_value(radio[:details] ||= {}, label.tr(" -", "__").to_sym, raw, issues, line)
+                next
+              end
+              section = nil if section && indent <= section_indent
+              if radio && section && SECTION_FIELDS.include?(label)
+                details = radio[:details] ||= {}
+                assign_value(details[section] ||= {}, label.to_sym, raw, issues, line)
+                next
+              end
               owner = radio && RADIO_FIELDS.key?(label) ? radio : ap
               mapping = owner.equal?(radio) && radio ? RADIO_FIELDS : AP_FIELDS
               details = AP_DETAILS.include?(label) ? ap : RADIO_DETAILS.include?(label) ? radio : nil
@@ -65,13 +87,17 @@ module Wireless
             issues << { code: :invalid_identity } if missing
             missing
           end
-          total = count(text, "APs")
+          total = record_count(text, "APs", issues)
           issues << { code: :count_mismatch, expected: total, parsed: valid_aps.size } if total && total != valid_aps.size
-          # AP 总数证明共享命令的覆盖范围，不代表 Radio 数量。
-          radio_total = total && total == valid_aps.size ? radios.size : nil
-          CtxParser::ResultSet.new(results: {
+          # AP 总数只证明 AP 范围；未报告 Radio 的 AP 不能证明其 Radio 清单为空。
+          radio_issues = issues.dup
+          valid_aps.each do |record|
+            radio_issues << { code: :missing_radio_evidence, ap_name: record[:name] } unless aps_with_radio_evidence.key?(record)
+          end
+          radio_total = total == 0 && valid_aps.empty? ? 0 : nil
+          CtxParser::Results.new(by_dimension: {
             access_points: Fields.result(valid_aps, issues: issues.dup, complete: complete, total: total, identity: [ :name ]),
-            radios: Fields.result(radios, issues: issues.dup, complete: complete, total: radio_total, identity: %i[ap_name radio_id])
+            radios: Fields.result(radios, issues: radio_issues, complete: complete, total: radio_total, identity: %i[ap_name radio_id])
           })
         end
       end

data/lib/wireless/h3c/parsers/display_wlan_ap_model_all.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "../verbose_parser"
+require_relative "../record_parser"
 
 module Wireless
   module H3c
     module Parsers
       # 型号能力与发现的 AP 资产及 Radio 分开保存。
-      class DisplayWlanApModelAll < VerboseParser
+      class DisplayWlanApModelAll < RecordParser
         MODEL_FIELDS = { "alias" => :alias, "vendor name" => :vendor_name, "vendor id" => :vendor_id,
           "license weight" => :license_weight, "license type" => :license_type, "radio count" => :radio_count, "type" => :type }.freeze
         RADIO_FIELDS = { "mode" => :modes, "default mode" => :default_mode, "bss count" => :bss_count }.freeze
@@ -22,8 +22,8 @@ module Wireless
           lines = text.lines
           model = section = nil
           mapping = MODEL_FIELDS
-          tokens(text, issues).each do |label, raw, line|
-            safely(issues, line) do
+          read_fields(text, issues).each do |label, raw, line|
+            parse_field(issues, line) do
               if label == "ap model"
                 raise ArgumentError, "Missing AP model" unless raw
                 model = { model: raw, radios: [], versions: [] }
@@ -48,7 +48,7 @@ module Wireless
             end
           end
           records.each { |record| validate_model(record, issues) }
-          Fields.result(records, issues: issues, complete: complete, total: count(text, "AP models"), identity: [ :model ])
+          Fields.result(records, issues: issues, complete: complete, total: record_count(text, "AP models", issues), identity: [ :model ])
         end
 
         # 根据声明字段类型归一化型号能力值。

data/lib/wireless/h3c/parsers/display_wlan_bss_all_verbose.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "../session_parser"
+require_relative "../record_parser"
 
 module Wireless
   module H3c
     module Parsers
       # 同时接受以 BSSID 或 AP 名称开头的 BSS 块。
-      class DisplayWlanBssAllVerbose < SessionParser
+      class DisplayWlanBssAllVerbose < RecordParser
         MAPPING = COMMON_FIELDS.merge("service template" => :profile, "service template name" => :profile,
           "state" => :operational_status, "client count" => :client_count, "number of clients" => :client_count,
           "online clients" => :client_count).freeze
@@ -17,7 +17,7 @@ module Wireless
         private
 
         # 返回当前命令格式中用于开始新记录的字段。
-        def start_label(fields)
+        def record_start_label(fields)
           first = fields.find { |label,| label == "bssid" || label == "ap name" }
           "ap name" if first&.first == "ap name"
         end
@@ -27,10 +27,10 @@ module Wireless
           super && record[:ap_name] && !record[:ap_name].strip.empty? && !record[:radio_id].nil?
         end
 
-        # 保留 BSS 安全字段，其余字段委派给共享会话解析器。
-        def assign_session_field(record, label, raw, issues, line)
+        # 保留 BSS 安全字段，其余字段委派给共享记录解析器。
+        def assign_record_field(record, label, raw, issues, line)
           if SECURITY.include?(label)
-            (record[:security] ||= {})[label.tr(" -", "__").to_sym] = raw
+            assign_value(record[:security] ||= {}, label.tr(" -", "__").to_sym, raw, issues, line)
           else
             super
           end