wireless-rb 0.1.0 → 0.2.0

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

@@ -16,12 +16,12 @@ module Wireless
             row = line.strip
             next if row.empty? || /\A[-=]+\z/.match?(row) || /\A(?:No blocked clients|MAC address\b.*|(?:Client )?block list|Blocked clients|Total.*:\s*\d+)\z/i.match?(row)
             if (match = /\A((?:[0-9a-f]{4}-){2}[0-9a-f]{4}|(?:[0-9a-f]{2}:){5}[0-9a-f]{2})\s*(.*?)\z/i.match(row))
-              records << { mac_address: Fields.mac(match[1]), reason: match[2] }
+              records << { mac_address: Fields.mac_address(match[1]), reason: match[2] }
             else
               issues << { code: :unrecognized_line, line: index + 1 }
             end
           end
-          total = /Total[^\n:]*:\s*(\d+)/i.match(text)&.[](1)&.to_i
+          total = reported_total(text, noun: "(?:blocked clients|clients)", issues: issues)
           total = 0 if /\ANo blocked clients\s*$/i.match?(text.strip)
           Fields.result(records, issues: issues, complete: complete, total: total, identity: [ :mac_address ])
         end

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

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require_relative "../session_parser"
+require_relative "../record_parser"
 
 module Wireless
   module H3c
     module Parsers
       # 解析客户端会话，区分相对 RSSI 与实测 dBm。
-      class DisplayWlanClientVerbose < SessionParser
+      class DisplayWlanClientVerbose < RecordParser
         MAPPING = COMMON_FIELDS.merge("mac address" => :client_mac, "ipv4 address" => :client_ip,
           "ip address" => :client_ip, "ipv6 address" => :client_ipv6, "username" => :username,
           "channel" => :channel, "frequency band" => :band, "state" => :operational_status, "status" => :operational_status,
           "wireless mode" => :protocol, "channel bandwidth" => :channel_width, "sm power save mode" => :power_save,
-          "sm power save" => :power_save, "qos mode" => :qos, "online time" => :uptime_seconds,
+          "sm power save" => :power_save, "qos mode" => :qos, "online time" => :online_seconds,
           "authentication method" => :auth_method, "security mode" => :security, "akm mode" => :akm,
           "cipher suite" => :cipher).freeze
         DETAILS = [ "authorization car", "authorization acl id", "authorization user profile", "key derivation",
@@ -29,15 +29,21 @@ module Wireless
         private
 
         # 归一化成对客户端速率，区分相对 RSSI 与实测 dBm。
-        def assign_session_field(record, label, raw, issues, line)
+        def assign_record_field(record, label, raw, issues, line)
           case label
           when "rx/tx rate"
-            safely(issues, line) { record[:rx_rate_mbps], record[:tx_rate_mbps] = Fields.rates(raw) }
+            parse_field(issues, line) do
+              rx, tx = Fields.rates_mbps(raw)
+              assign_value(record, :rx_rate_mbps, rx, issues, line)
+              assign_value(record, :tx_rate_mbps, tx, issues, line)
+            end
           when "rssi"
-            safely(issues, line) do
+            parse_field(issues, line) do
               signal = Fields.number(raw, unit: "dBm")
-              record[:signal_dbm] = signal if signal&.negative?
-              record[:rssi] = signal.round if signal&.positive?
+              assign_value(record, :signal_dbm, signal&.negative? ? signal : nil, issues, line)
+              assign_value(record, :rssi, signal&.positive? ? signal.round : nil, issues, line)
+              record.delete(:signal_dbm) if record[:signal_dbm].nil?
+              record.delete(:rssi) if record[:rssi].nil?
             end
           else
             super

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

@@ -41,8 +41,8 @@ module Wireless
           month, day, hour, minute, second = match[6].split(/[- :]/).map(&:to_i)
           raise ArgumentError, "Invalid conflict time" unless Date.valid_date?(2000, month, day) && hour < 24 && minute < 60 && second < 60
 
-          { ip_address: Fields.ip(match[1]), new_mac_address: Fields.mac(match[2]), new_ap_id: Fields.integer(match[3]).to_s,
-            old_mac_address: Fields.mac(match[4]), old_ap_id: Fields.integer(match[5]).to_s, occurred_at: match[6] }
+          { ip_address: Fields.ip_address(match[1]), new_mac_address: Fields.mac_address(match[2]), new_ap_id: Fields.integer(match[3]).to_s,
+            old_mac_address: Fields.mac_address(match[4]), old_ap_id: Fields.integer(match[5]).to_s, occurred_at: match[6] }
         end
       end
     end

data/lib/wireless/h3c/profile.rb

@@ -16,7 +16,7 @@ module Wireless
   module H3c
     # 声明 H3C 控制器及 AP 策略，共享回显仅解析一次后再投影维度。
     class Profile < CtxParser::Profile
-      CATALOG = CtxParser::CommandCatalog.new([
+      DECLARATIONS = CtxParser::Commands.new([
         { dimensions: [ :client_ip_conflicts ], command: "display wlan statistics client-ip-conflict", parser: Parsers::DisplayWlanStatisticsClientIpConflict },
         { dimensions: [ :ap_models ], command: "display wlan ap-model all", parser: Parsers::DisplayWlanApModelAll },
         { dimensions: %i[access_points radios], command: "display wlan ap all verbose", parser: Parsers::DisplayWlanApAllVerbose },
@@ -28,8 +28,11 @@ module Wireless
         { dimensions: [ :blocked_clients ], command: "display wlan client-security block-mac", parser: Parsers::DisplayWlanClientSecurityBlockMac },
         { dimensions: [ :lldp ], command: "display lldp neighbor-information verbose", parser: Parsers::DisplayLldpNeighborInformationVerbose }
       ])
-      COMMANDS = CATALOG.commands
-      PARSERS = CATALOG.parsers
+      COMMANDS = DECLARATIONS.by_dimension
+      PARSERS = DECLARATIONS.parsers
+
+      # 本平台在当前控制器会话禁用分页。
+      def preparation_command = "screen-length disable"
 
       private
 

data/lib/wireless/h3c/record_parser.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "parser"
+
+module Wireless
+  module H3c
+    # 按字段标签划分 H3C 详细记录，并共享字段转换与诊断。
+    class RecordParser < Parser
+      COMMON_FIELDS = { "ap name" => :ap_name, "ap id" => :ap_id, "radio id" => :radio_id,
+        "ssid" => :ssid, "bssid" => :bssid, "vlan id" => :vlan, "service vlan id" => :vlan }.freeze
+      DETAILS = [].freeze
+
+      private
+
+      # 各命令声明记录身份与字段映射，嵌套记录可覆盖此入口。
+      def parse_text(text, complete:)
+        issues, records = [], []
+        fields = read_fields(text, issues)
+        start_label = record_start_label(fields)
+        current = nil
+        fields.each do |label, raw, line|
+          if start_label ? label == start_label : self.class::MAPPING[label] == self.class::IDENTITY.first
+            current = {}
+            records << current
+          end
+          unless current
+            issues << { code: :missing_identity, line: line }
+            next
+          end
+          assign_record_field(current, label, raw, issues, line)
+        end
+        records.reject! do |record|
+          invalid = !valid_identity?(record)
+          issues << { code: :invalid_identity } if invalid
+          invalid
+        end
+        Fields.result(records, issues: issues, complete: complete, total: record_count(text, self.class::COUNT, issues), identity: self.class::IDENTITY)
+      end
+
+      # 返回字段标签、原始值与来源行号，保留明确允许的续行。
+      def read_fields(text, issues)
+        text.lines.each_with_index.each_with_object([]) do |(line, index), fields|
+          row = line.strip
+          next if row.empty? || /\A[-=]+\z/.match?(row)
+          if (match = /\A([^:]+?)\s*:\s*(.*)\z/.match(row))
+            label = match[1].downcase.gsub(/\s+/, " ")
+            next if /\A(?:total|number of aps|connected|remaining|maximum|current number|(?:local|server|sync) ap licenses|(?:current|max|bound) bss number)\b/.match?(label)
+            fields << [ label, Fields.value(match[2]), index + 1, line[/\A\s*/].size ]
+          elsif (match = /\A:\s*(\S.*)\z/.match(row)) && fields.last&.first == "poe status"
+            fields.last[1] = [ fields.last[1], match[1] ].compact.join("\n")
+          elsif /\A(?:NSS\d+\s+[\d, ]+|TID \d+\s+(?:In|Out|Both)|[\d., ]+(?:Mbps)?)\z/.match?(row)
+            next
+          else
+            issues << { code: :unrecognized_line, line: index + 1 }
+          end
+        end
+      end
+
+      # 更新当前记录前，先应用字段专用转换。
+      def assign_field(record, mapping, label, raw, issues, line, details:)
+        if record && (field = mapping[label])
+          parse_field(issues, line) do
+            # 优先使用运行带宽；80+80MHz 等歧义值保持原义，不截断为单个数值。
+            if field == :channel_width
+              label = "channel bandwidth" if label == "channel band-width"
+              assign_value(record[:details] ||= {}, label.tr(" ", "_").to_sym, raw, issues, line)
+              return if label == "channel bandwidth" && @field_assignments.fetch(record[:details]).key?(:operating_bandwidth)
+            end
+            assign_value(record, field, convert_field(field, raw, label: label), issues, line, identity: field == :channel_width ? label : field)
+          end
+        elsif details
+          value = label.end_with?("url") ? !raw.nil? && !raw.strip.empty? : raw
+          assign_value(details[:details] ||= {}, label.tr(" -", "__").to_sym, value, issues, line)
+        else
+          issues << { code: :unrecognized_field, line: line }
+        end
+      end
+
+      # 按声明的归一化规则转换已知字段。
+      def convert_field(field, raw, label:)
+        case field
+        when :mac_address, :client_mac, :bssid then Fields.mac_address(raw)
+        when :management_ip, :client_ip, :client_ipv6, :ip_address, :ipv6_address
+          address = Fields.ip_address(raw)
+          if address && ((label == "ipv4 address" && address.include?(":")) || (label == "ipv6 address" && !address.include?(":")))
+            raise ArgumentError, "Invalid wireless address family"
+          end
+          address
+        when :ap_id, :radio_id then Fields.integer(raw)&.to_s
+        when :client_count, :online_seconds, :uptime_seconds
+          %i[online_seconds uptime_seconds].include?(field) ? Fields.duration_seconds(raw) : Fields.integer(raw)
+        when :vlan, :initial_vlan_id, :authorized_vlan_id
+          vlan = Fields.integer(raw, max: 4094)
+          raise ArgumentError, "Invalid wireless VLAN" if vlan && vlan.zero?
+          vlan
+        when :channel then Fields.channel(raw)
+        when :channel_width then Fields.channel_width_mhz(raw)
+        when :band then Fields.frequency_band(raw)
+        when :noise_dbm then Fields.number(raw, unit: "dBm")&.then { |number| number if number.negative? }
+        when :utilization
+          number = Fields.number(raw, unit: "%")
+          raise ArgumentError, "Invalid wireless utilization" if number && !(0..100).cover?(number)
+          number&.round
+        else raw
+        end
+      end
+
+      # 解析非负计数，同时保留未知值。
+      def record_count(text, noun, issues)
+        reported_total(text, noun: noun, issues: issues)
+      end
+
+      # 隔离单个格式错误字段，同时保留无关记录数据。
+      def parse_field(issues, line)
+        yield
+      rescue ArgumentError, IPAddr::InvalidAddressError
+        issues << { code: :invalid_field, line: line }
+      end
+
+      # 默认以身份字段开始新记录，命令可声明其他起始标签。
+      def record_start_label(fields)
+        nil
+      end
+
+      # 要求具备关联当前记录所需的稳定身份字段。
+      def valid_identity?(record)
+        value = record[self.class::IDENTITY.first]
+        value && !value.strip.empty?
+      end
+
+      # 将命令字段归一化到当前记录，并保留显式允许的详情。
+      def assign_record_field(record, label, raw, issues, line)
+        details = self.class::DETAILS.include?(label) ? record : nil
+        assign_field(record, self.class::MAPPING, label, raw, issues, line, details: details)
+      end
+    end
+  end
+end

data/lib/wireless/huawei/parser.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "../fields"
+require_relative "../terminal"
+require "ctx_parser/parser"
+
+module Wireless
+  module Huawei
+    # 仅支持有证据的 Huawei 表格格式，区分不支持维度与空清单。
+    class Parser < CtxParser::Parser
+      private
+
+      # 标准解析边界负责参数校验，子类只选择对应命令的维度。
+      def parse_output(text, complete:)
+        name = self.class::DIMENSION
+        text = Fields.text(text)
+        if Terminal.unsupported?(text)
+          return CtxParser::Result.new(status: :unsupported, issues: [ { code: :unsupported_command } ])
+        end
+        if (issue = Terminal.issue(text))
+          return CtxParser::Result.new(status: :partial, issues: [ issue ])
+        end
+        records, issues = [], []
+        header = false
+        total = nil
+        text.lines.each_with_index do |line, index|
+          row = line.strip
+          next if row.empty? || /\A[-=]+\z/.match?(row)
+          if (match = /\ATotal\s*:\s*(\d+)\z/i.match(row))
+            reported = match[1].to_i
+            issues << { code: :conflicting_total, line: index + 1 } if total && total != reported
+            total ||= reported
+          elsif name == :access_points ? /\AID\s+MAC\s+Name\s+Group\s+IP\s+Type\s+State\s+STA\s+Uptime\b/i.match?(row) : /\ASTA MAC\s+AP ID\s+Ap name\s+Rf\/WLAN\b/i.match?(row)
+            header = true
+          elsif /\ATotal AP information:|\A(?:nor|fault|idle|stdby)\s*:/i.match?(row)
+            next
+          elsif !header
+            issues << { code: :missing_header, line: index + 1 }
+          else
+            begin
+              records << (name == :access_points ? ap(row.split) : client(row.split))
+            rescue ArgumentError, IPAddr::InvalidAddressError
+              issues << { code: :invalid_row, line: index + 1 }
+            end
+          end
+        end
+        issues << { code: :missing_header } unless header
+        result = Fields.result(records, issues: issues, complete: complete, total: total, identity: [ name == :access_points ? :name : :client_mac ])
+        result
+      rescue ArgumentError, IPAddr::InvalidAddressError
+        CtxParser::Result.new(status: :failed, issues: [ { code: :invalid_output } ])
+      end
+
+      private
+
+      # IPv6 专用列不能接受合法但属于 IPv4 的地址。
+      def ipv6_address(raw)
+        address = Fields.ip_address(raw)
+        raise ArgumentError, "Invalid station IPv6 address" if address && !address.include?(":")
+        address
+      end
+
+      # 归一化控制器报告的单条 AP 记录。
+      def ap(columns)
+        raise ArgumentError, "Invalid AP row" unless columns.size == 9
+        id, mac, name, group, ip, model, state, clients, uptime = columns
+        { ap_id: Fields.integer(id).to_s, mac_address: Fields.mac_address(mac), name: name, group_name: group,
+          management_ip: Fields.ip_address(Fields.value(ip)), model: model, operational_status: Fields.online_status(state),
+          client_count: Fields.integer(clients), uptime_seconds: Fields.duration_seconds(Fields.value(uptime)) }
+      end
+
+      # 归一化控制器报告的单条无线客户端记录。
+      def client(columns)
+        raise ArgumentError, "Invalid station row" unless columns.size == 15
+        mac, ap_id, ap_name, radio_wlan, band, protocol, rates, rssi, vlan, ip, ssid, state, ipv6, _ac_id, uptime = columns
+        raise ArgumentError, "Invalid station identity" unless /\A\d+\/\d+\z/.match?(radio_wlan)
+        rx, tx = Fields.rates_mbps(rates)
+        signal = Fields.number(Fields.value(rssi), unit: "dBm")
+        { client_mac: Fields.mac_address(mac), ap_id: Fields.integer(ap_id).to_s, ap_name: ap_name, radio_id: radio_wlan.split("/").first,
+          band: Fields.frequency_band(band), protocol: protocol, rx_rate_mbps: rx, tx_rate_mbps: tx, signal_dbm: signal == 0 ? nil : signal,
+          vlan: Fields.integer(vlan, max: 4094), client_ip: Fields.ip_address(Fields.value(ip)), ssid: ssid, operational_status: state,
+          client_ipv6: ipv6_address(Fields.value(ipv6)), uptime_seconds: Fields.duration_seconds(Fields.value(uptime)) }
+      end
+    end
+  end
+end

data/lib/wireless/huawei/parsers/display_ap_all.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../parser"
+
+module Wireless
+  module Huawei
+    module Parsers
+      # 解析对应 Huawei 无线查询的表格事实。
+      class DisplayApAll < Parser
+        DIMENSION = :access_points
+      end
+    end
+  end
+end

data/lib/wireless/huawei/parsers/display_station_all.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../parser"
+
+module Wireless
+  module Huawei
+    module Parsers
+      # 解析对应 Huawei 无线查询的表格事实。
+      class DisplayStationAll < Parser
+        DIMENSION = :clients
+      end
+    end
+  end
+end

data/lib/wireless/huawei/profile.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "ctx_parser/profile"
+require_relative "parsers/display_ap_all"
+require_relative "parsers/display_station_all"
+
+module Wireless
+  module Huawei
+    # Huawei 查询通过相同命令声明和参数协议进入采集与解析。
+    class Profile < CtxParser::Profile
+      DECLARATIONS = CtxParser::Commands.new([
+        { dimensions: [ :access_points ], command: "display ap all", parser: Parsers::DisplayApAll },
+        { dimensions: [ :clients ], command: "display station all", parser: Parsers::DisplayStationAll }
+      ])
+      COMMANDS = DECLARATIONS.by_dimension
+      PARSERS = DECLARATIONS.parsers
+
+      # 本平台使用临时会话分页设置。
+      def preparation_command = "screen-length 0 temporary"
+    end
+  end
+end

data/lib/wireless/observation.rb

@@ -7,6 +7,7 @@ module Wireless
   Observation = Data.define(:name, :status, :records, :issues, :evidence, :started_at, :completed_at) do
     # 冻结单个维度的记录、状态及诊断元数据。
     def initialize(name:, status:, records: [], issues: [], evidence: [], started_at: nil, completed_at: nil)
+      raise ArgumentError, "Wireless observation name must be a symbol" unless name.is_a?(Symbol)
       raise ArgumentError, "Invalid wireless observation status" unless %i[complete partial failed unsupported not_requested].include?(status)
       raise ArgumentError, "Wireless records must be hashes" unless records.is_a?(Array) && records.all? { |record| record.is_a?(Hash) }
       raise ArgumentError, "Unavailable wireless observation has records" if %i[failed unsupported not_requested].include?(status) && records.any?
@@ -24,5 +25,6 @@ module Wireless
     def available? = complete? || partial?
     # 展示对象身份与状态，避免泄露原始回显或凭据。
     def inspect = "#<#{self.class.name} name=#{name} status=#{status} records=#{records.size}>"
+    alias to_s inspect
   end
 end

data/lib/wireless/parser_registry.rb

@@ -2,8 +2,9 @@
 
 require "ctx_parser/registry"
 require_relative "h3c/profile"
+require_relative "huawei/profile"
 
 module Wireless
   # 将 h3c_wireless 视为 H3C 无线平台策略的连接器别名。
-  ParserRegistry = CtxParser::Registry.new(profiles: { h3c: H3c::Profile }, aliases: { h3c_wireless: :h3c })
+  ParserRegistry = CtxParser::Registry.new(profiles: { h3c: H3c::Profile, huawei: Huawei::Profile }, aliases: { h3c_wireless: :h3c })
 end

data/lib/wireless/projection.rb

@@ -12,5 +12,9 @@ module Wireless
 
     # 判断所有请求的资产投影是否均已完成。
     def complete? = dimensions.values.all? { |entry| entry.fetch(:status) == :complete }
+
+    # 展示应用范围，不在日志字符串中序列化应用详情。
+    def inspect = "#<#{self.class.name} dimensions=#{dimensions.size}>"
+    alias to_s inspect
   end
 end

data/lib/wireless/runtime_parser.rb

@@ -2,15 +2,16 @@
 
 require_relative "parser_registry"
 require_relative "fields"
-require_relative "huawei_runtime"
 require_relative "observation"
 
 module Wireless
-  # 将平台解析结果映射为无线维度，同时保留 Huawei 解析入口。
+  # 按平台解析无线观测，统一保留各维度的完整性与诊断。
   class RuntimeParser
     # 保留型号选择信息，供每次解析所选平台使用。
     def initialize(model: nil)
-      @model = model
+      raise ArgumentError, "Device model must be text" unless model.nil? || model.is_a?(String)
+
+      @model = model&.dup&.freeze
     end
 
     # 使用传入平台及保留的型号选择解析单个无线维度。
@@ -20,21 +21,25 @@ module Wireless
 
     # 共享命令仅解析一次，再投影各请求维度。
     def parse_many(names, content, platform: "h3c", complete: false)
-      text = Fields.text(content)
-      if H3c::Parser::UNSUPPORTED.match?(text)
-        return unavailable(names, :unsupported, :unsupported_command)
-      end
-      if platform.to_s == "huawei"
-        return names.to_h { |name| [ name, HuaweiRuntime.new.parse(name, text, complete: complete) ] }
+      unless names.is_a?(Array) && names.any? && names.all? { |name| name.is_a?(Symbol) } && names.uniq == names
+        raise ArgumentError, "Dimensions must be unique symbols"
       end
+      raise ArgumentError, "Completeness must be boolean" unless [ true, false ].include?(complete)
+      raise ArgumentError, "Parser input must be text" unless content.is_a?(String)
 
       profile = ParserRegistry.fetch(platform, model: @model)
+      begin
+        text = Fields.text(content, newlines: :preserve)
+      rescue ArgumentError
+        return unavailable(names, :failed, :invalid_output)
+      end
+      if Terminal.unsupported?(text)
+        return unavailable(names, :unsupported, :unsupported_command)
+      end
       supported, unsupported = names.partition { |name| profile.commands.key?(name) }
       results = supported.empty? ? {} : profile.parse_many(supported, text, complete: complete)
       observations = results.to_h { |name, result| [ name, Observation.new(name: name, **result.to_h) ] }
       observations.merge(unavailable(unsupported, :unsupported, :unsupported_platform_dimension))
-    rescue ArgumentError, IPAddr::InvalidAddressError
-      unavailable(names, :failed, :invalid_output)
     end
 
     private

data/lib/wireless/snapshot.rb

@@ -16,7 +16,7 @@ module Wireless
           observed_at.is_a?(Time)
         raise ArgumentError, "Invalid wireless snapshot"
       end
-      super(target: CtxParser::Immutable.copy(target), dimensions: dimensions.dup.freeze,
+      super(target: CtxParser::Immutable.copy(target), dimensions: dimensions.to_h { |name, value| [ name, value ] }.freeze,
         observed_at: observed_at.dup.freeze)
     end
 
@@ -33,5 +33,6 @@ module Wireless
 
     # 展示对象身份与状态，避免泄露原始回显或凭据。
     def inspect = "#<#{self.class.name} complete=#{complete?}>"
+    alias to_s inspect
   end
 end

data/lib/wireless/terminal.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "ctx_parser/banner"
+
+module Wireless
+  # 分页及终端编辑控制会破坏事实边界；正常换行和制表符仍是来源文本。
+  module Terminal
+    INVALID = /--[ \t]*More[ \t]*--|[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/i
+    private_constant :INVALID
+
+    UNSUPPORTED = /(?:\A|(?<=[\r\n]))[ \t]*(?:%[ \t]*)?(?:Unrecognized command\b|Wrong parameter\b|Invalid (?:input|command)\b|Unknown command\b|Error:[^\r\n]*\bcommand\b)[^\r\n]*/i
+
+    private_constant :UNSUPPORTED
+
+    # 错误响应须独占来源行；横幅正文不是设备命令诊断。
+    def self.unsupported?(text)
+      banner = CtxParser::Banner.new
+      text.split(/\r\n?|\n/).any? { |line| !banner.consume(line.strip) && UNSUPPORTED.match?(line) }
+    end
+
+    # 在字段清理之前检测终端残留，避免将编辑后的文本接受为事实。
+    def self.invalid_output?(text) = INVALID.match?(text)
+
+    # 运行回显无可恢复的来源树，返回首个受损来源行的安全诊断。
+    def self.issue(text)
+      return unless invalid_output?(text)
+
+      line = text.split(/\r\n?|\n/).find_index { |source| invalid_output?(source) }
+      { code: :invalid_terminal_output, line: line + 1 }
+    end
+  end
+end

data/lib/wireless/version.rb

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

data/lib/wireless.rb

@@ -12,7 +12,5 @@ require_relative "wireless/projection"
 require_relative "wireless/coverage"
 require_relative "wireless/configuration"
 require_relative "wireless/runtime_parser"
-require_relative "wireless/h3c_runtime"
 require_relative "wireless/neighbor_parser"
-require_relative "wireless/ap_session"
 require_relative "wireless/collector"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wireless-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Gatework contributors
@@ -51,20 +51,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: net-connector
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: time
   requirement: !ruby/object:Gem::Requirement
@@ -98,9 +84,10 @@ files:
 - lib/wireless/configuration.rb
 - lib/wireless/coverage.rb
 - lib/wireless/fields.rb
-- lib/wireless/h3c/authentication_parser.rb
+- lib/wireless/h3c/authentication.rb
 - lib/wireless/h3c/command_output.rb
 - lib/wireless/h3c/configuration.rb
+- lib/wireless/h3c/document.rb
 - lib/wireless/h3c/parser.rb
 - lib/wireless/h3c/parsers/display_current_configuration.rb
 - lib/wireless/h3c/parsers/display_dot1x_connection.rb
@@ -113,16 +100,18 @@ files:
 - lib/wireless/h3c/parsers/display_wlan_client_verbose.rb
 - lib/wireless/h3c/parsers/display_wlan_statistics_client_ip_conflict.rb
 - lib/wireless/h3c/profile.rb
-- lib/wireless/h3c/session_parser.rb
-- lib/wireless/h3c/verbose_parser.rb
-- lib/wireless/h3c_runtime.rb
-- lib/wireless/huawei_runtime.rb
+- lib/wireless/h3c/record_parser.rb
+- lib/wireless/huawei/parser.rb
+- lib/wireless/huawei/parsers/display_ap_all.rb
+- lib/wireless/huawei/parsers/display_station_all.rb
+- lib/wireless/huawei/profile.rb
 - lib/wireless/neighbor_parser.rb
 - lib/wireless/observation.rb
 - lib/wireless/parser_registry.rb
 - lib/wireless/projection.rb
 - lib/wireless/runtime_parser.rb
 - lib/wireless/snapshot.rb
+- lib/wireless/terminal.rb
 - lib/wireless/version.rb
 homepage: https://github.com/gatework/wireless-rb
 licenses:

data/lib/wireless/h3c/session_parser.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "verbose_parser"
-
-module Wireless
-  module H3c
-    # 复用详细会话边界，各命令独立声明其字段结构。
-    class SessionParser < VerboseParser
-      COMMON_FIELDS = { "ap name" => :ap_name, "ap id" => :ap_id, "radio id" => :radio_id,
-        "ssid" => :ssid, "bssid" => :bssid, "vlan id" => :vlan, "service vlan id" => :vlan }.freeze
-      DETAILS = [].freeze
-
-      private
-
-      # 解释当前命令记录，保留不完整行诊断。
-      def parse_text(text, complete:)
-        issues, records = [], []
-        fields = tokens(text, issues)
-        start = start_label(fields)
-        current = nil
-        fields.each do |label, raw, line|
-          if start ? label == start : self.class::MAPPING[label] == self.class::IDENTITY.first
-            current = {}
-            records << current
-          end
-          unless current
-            issues << { code: :missing_identity, line: line }
-            next
-          end
-          assign_session_field(current, label, raw, issues, line)
-        end
-        records.reject! do |record|
-          invalid = !valid_identity?(record)
-          issues << { code: :invalid_identity } if invalid
-          invalid
-        end
-        Fields.result(records, issues: issues, complete: complete, total: count(text, self.class::COUNT), identity: self.class::IDENTITY)
-      end
-
-      # 返回当前命令格式中用于开始新记录的字段。
-      def start_label(fields)
-        nil
-      end
-
-      # 要求具备关联当前记录所需的稳定身份字段。
-      def valid_identity?(record)
-        value = record[self.class::IDENTITY.first]
-        value && !value.strip.empty?
-      end
-
-      # 将单个认证会话字段归一化到目标记录。
-      def assign_session_field(record, label, raw, issues, line)
-        details = self.class::DETAILS.include?(label) ? record : nil
-        assign_field(record, self.class::MAPPING, label, raw, issues, line, details: details)
-      end
-    end
-  end
-end