wireless-rb 0.1.0 → 0.2.0

data/lib/wireless/configuration.rb

@@ -15,8 +15,6 @@ module Wireless
     def parse(content, complete: false)
       result = @profile.parse(:configuration, content, complete: complete)
       Observation.new(name: :configuration, **result.to_h)
-    rescue ArgumentError
-      Observation.new(name: :configuration, status: :failed, issues: [ { code: :invalid_output } ])
     end
   end
 end

data/lib/wireless/coverage.rb

@@ -7,24 +7,34 @@ module Wireless
   class Coverage
     # 绑定观测、投影结果及请求的新鲜度时间窗。
     def initialize(observations:, projection:, dimensions:, now:, stale_after:)
+      unless now.is_a?(Time) && stale_after.is_a?(Numeric) && stale_after.real? && stale_after.finite? && stale_after >= 0
+        raise ArgumentError, "Coverage requires a clock time and a finite nonnegative freshness window"
+      end
+
       @observations, @projection, @dimensions = observations, projection || {}, dimensions
-      @now, @stale_after = now, stale_after
+      @now, @stale_after_seconds = now, stale_after
     end
 
     # 历史资产清单不声明 CLI 完整性，保持既有纯 Netdisco 视图兼容。
     def to_h
       return { "state" => "untracked", "source" => "inventory", "dimensions" => {} } unless @observations
 
-      dimensions = @dimensions.to_h { |name| [ name.to_s, dimension(name.to_s) ] }
+      dimensions = @dimensions.to_h { |name| [ name.to_s, dimension_coverage(name.to_s) ] }
       states = dimensions.values.map { |entry| entry.fetch("state") }
-      state = states.all?("complete") ? "complete" : states.include?("unknown") ? "unknown" : "stale"
+      state = if states.empty? || states.include?("unknown")
+        "unknown"
+      elsif states.all?("complete")
+        "complete"
+      else
+        "stale"
+      end
       { "state" => state, "source" => "cli", "dimensions" => dimensions }
     end
 
     private
 
     # 新记录不能刷新旧命令或失败命令的时效；投影受阻不算完整覆盖。
-    def dimension(name)
+    def dimension_coverage(name)
       stored = @observations.fetch(name, {})
       latest = stored.fetch("latest", {})
       projection = @projection.fetch(name, {})
@@ -35,7 +45,7 @@ module Wireless
         [ "unknown", latest.empty? ? "not_requested" : "collection_#{latest['status']}" ]
       elsif !at || at > @now
         [ "unknown", "observation_time_unknown" ]
-      elsif @now - at > @stale_after
+      elsif @now - at > @stale_after_seconds
         [ "stale", "evidence_stale" ]
       elsif @projection.key?(name) && projected_at != at
         [ "unknown", "projection_time_unconfirmed" ]

data/lib/wireless/fields.rb

@@ -27,15 +27,15 @@ module Wireless
     end
 
     # 归一化 MAC 地址，拒绝格式错误的输入。
-    def mac(raw)
-      CtxParser::Values.mac(raw)
+    def mac_address(raw)
+      CtxParser::Values.mac_address(raw)
     rescue ArgumentError
       raise ArgumentError, "Invalid wireless MAC"
     end
 
     # 归一化 IP 主机地址，拒绝无效无线身份数据。
-    def ip(raw)
-      CtxParser::Values.host(raw)
+    def ip_address(raw)
+      CtxParser::Values.ip_address(raw)
     rescue IPAddr::Error
       raise
     rescue ArgumentError
@@ -56,11 +56,15 @@ module Wireless
       return if raw.nil?
       match = /\A(-?\d+(?:\.\d+)?)\s*(?:#{Regexp.escape(unit.to_s)})?\z/i.match(raw.to_s)
       raise ArgumentError, "Invalid wireless number" unless match
-      Float(match[1])
+
+      measurement = Float(match[1])
+      raise ArgumentError, "Invalid wireless number" unless measurement.finite?
+
+      measurement
     end
 
     # 将支持的时长格式转换为秒，并校验各时间分量。
-    def duration(raw)
+    def duration_seconds(raw)
       return if raw.nil?
       if /\A\d+:\d{2}:\d{2}:\d{2}\z/.match?(raw)
         days, hours, minutes, seconds = raw.split(":").map(&:to_i)
@@ -74,12 +78,17 @@ module Wireless
     end
 
     # 将成对收发速率转换为每秒兆比特。
-    def rates(raw)
+    def rates_mbps(raw)
       return [ nil, nil ] if raw.nil?
       match = /\A(\d+(?:\.\d+)?)\s*\/\s*(\d+(?:\.\d+)?)\s*([kmgt]?bps)?\z/i.match(raw)
       raise ArgumentError, "Invalid wireless rates" unless match
       multiplier = { "bps" => 0.000001, "kbps" => 0.001, "mbps" => 1, "gbps" => 1000, "tbps" => 1_000_000 }.fetch((match[3] || "Mbps").downcase)
-      [ match[1], match[2] ].map { |value| Float(value) * multiplier }
+      [ match[1], match[2] ].map do |value|
+        rate = Float(value) * multiplier
+        raise ArgumentError, "Invalid wireless rates" unless rate.finite?
+
+        rate
+      end
     end
 
     # 解析明确无线信道；自动选择仍保持未知。
@@ -92,22 +101,18 @@ module Wireless
     end
 
     # 将支持的 MHz 回显归一化为正数信道宽度。
-    def width(raw)
+    def channel_width_mhz(raw)
       match = /\A(\d+)\s*(?:MHz)?\z/i.match(raw.to_s)
       match[1].to_i if match && match[1].to_i.positive?
     end
 
-    # 根据明确标签或支持的信道范围确定无线频段。
-    def band(hint, channel: nil)
-      return "6GHz" if /6\s*g(?:hz)?/i.match?(hint.to_s)
-      return "5GHz" if /5\s*g(?:hz)?/i.match?(hint.to_s)
-      return "2.4GHz" if /2\.?4\s*g(?:hz)?|802\.11[bg](?:\b|\/)/i.match?(hint.to_s)
-      return unless channel
-      case channel
-      when 1..14 then "2.4GHz"
-      when 15..199 then "5GHz"
-      when 200..233 then "6GHz"
-      end
+    # 信道编号在不同频段重叠，频段须由明确标签或专属 PHY 证据确定。
+    def frequency_band(hint)
+      bands = []
+      bands << "6GHz" if /(?<![\d.])6\s*g(?:hz)?\b/i.match?(hint.to_s)
+      bands << "5GHz" if /(?<![\d.])5\s*g(?:hz)?\b/i.match?(hint.to_s)
+      bands << "2.4GHz" if /(?<![\d.])2\.4\s*g(?:hz)?\b|802\.11[bg](?:\b|\/)/i.match?(hint.to_s)
+      bands.first if bands.one?
     end
 
     # 归一化已知在线、离线标签，同时保留未识别状态。

data/lib/wireless/h3c/{authentication_parser.rb → authentication.rb}

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "session_parser"
+require_relative "record_parser"
 
 module Wireless
   module H3c
-    # 认证命令共享字段语法及复合会话身份。
-    class AuthenticationParser < SessionParser
-      MAPPING = COMMON_FIELDS.except("vlan id", "service vlan id").merge(
+    # 认证命令共享字段映射、详情及复合会话身份。
+    module Authentication
+      MAPPING = RecordParser::COMMON_FIELDS.except("vlan id", "service vlan id").merge(
         "mac address" => :mac_address, "user mac address" => :mac_address, "username" => :username, "user name" => :username,
         "access interface" => :interface, "interface" => :interface, "ip address" => :ip_address,
         "ipv4 address" => :ip_address, "ipv6 address" => :ipv6_address, "authentication domain" => :domain, "domain" => :domain,

data/lib/wireless/h3c/command_output.rb

@@ -1,27 +1,68 @@
 # frozen_string_literal: true
 
 require_relative "../fields"
+require_relative "../terminal"
 
 module Wireless
   module H3c
     # 复用 H3C 输入校验；各命令实现 parse_text，配置解析保留原始换行。
     module CommandOutput
-      UNSUPPORTED = /(?:Unrecognized command|Wrong parameter|Invalid (?:input|command)|Unknown command|Error:[^\r\n]*command)/i
-
       private
 
       # 解释当前命令回显，保留不支持或格式错误的证据。
       def parse_output(text, complete:)
         text = Fields.text(text, newlines: output_newlines)
-        if UNSUPPORTED.match?(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
+
+        @field_assignments = {}.compare_by_identity
         parse_text(text, complete: complete)
       rescue ArgumentError, IPAddr::InvalidAddressError
         CtxParser::Result.new(status: :failed, issues: [ { code: :invalid_output } ])
       end
 
+      # 校验每条总数声明，不能用第一条匹配掩盖矛盾或损坏的尾行。
+      def reported_total(text, noun:, issues:, continuation_lines: nil)
+        prefix = /\A(?:Total\b|Number of (?:#{noun})\b|Current BSS number\b)/i
+        totals = []
+        text.each_line.with_index do |line, index|
+          row = line.strip
+          next if continuation_lines&.key?(index + 1)
+          next unless prefix.match?(row)
+          if (match = /\A(?:Total(?: number of)?(?:\s+(?:#{noun}))?|Number of (?:#{noun})|Current BSS number)\s*:\s*(\d+)\s*\z/i.match(row))
+            totals << match[1].to_i
+          else
+            issues << { code: :invalid_total, line: index + 1 }
+          end
+        end
+        issues << { code: :conflicting_total } if totals.uniq.size > 1
+        totals.first
+      end
+
+      # 同一字段允许等价重复；发生歧义后删除事实，后续声明不能恢复它。
+      def assign_value(record, field, value, issues, line, identity: field)
+        assignments = (@field_assignments[record] ||= {})
+        if (previous = assignments[identity])
+          if previous[:conflicted] || previous[:value] != value
+            record.delete(field)
+            issues << { code: :conflicting_field, line: line, first_line: previous[:line] }
+            previous[:conflicted] = true
+            return
+          end
+        else
+          assignments[identity] = { value: value, line: line }
+        end
+        record[field] = value
+      end
+
+      # 运行回显受损时不能继续信任任何字段。
+      def terminal_issue(text) = Terminal.issue(text)
+
       # 声明当前命令解析器所需的换行归一化方式。
       def output_newlines = :lf
     end

data/lib/wireless/h3c/configuration.rb

@@ -23,6 +23,7 @@ module Wireless
             raise ArgumentError, "Group radio requires a model"
           end
 
+          identity = identity.downcase
           collection = identity.end_with?("g") ? :band_defaults : :radios
           keys = [ collection, identity ]
           keys.unshift(:configuration) if kind == :ap_groups
@@ -37,7 +38,7 @@ module Wireless
 
         # 汇总已解析记录，并报告未解决或不完整的来源状态。
         def finish
-          record[:authentication_type] = authentication if kind == :service_templates
+          record[:authentication_type] = authentication_type if kind == :service_templates
           record
         end
 
@@ -51,29 +52,44 @@ module Wireless
         end
 
         # 解析实际生效的认证方法及外部服务器引用。
-        def authentication
+        def authentication_type
           mode = settings[:client_security_authentication_mode]
-          return "dot1x" if mode == "dot1x" || settings[:akm_modes].include?("dot1x") || settings[:dot1x_domain]
-          return "mab" if mode == "mac" || settings[:mac_authentication_domain]
+          return mode == "mac" ? "mab" : mode if mode
+          return "dot1x" if settings[:akm_modes].include?("dot1x")
           return "psk" if settings[:akm_modes].include?("psk") || settings[:has_preshared_key]
           return "portal" if settings[:portal]&.key?(:enable_method)
           nil
         end
       end
 
+      # 使用模板名索引绑定，保持数组输出并避免每条声明扫描既有绑定。
+      def bind_template(record, name, vlan_id)
+        bindings = (@template_bindings[record] ||= {})
+        binding = { name: name, vlan_id: vlan_id }
+        previous = bindings[name]
+        raise ArgumentError, "Conflicting template binding" if previous && previous != binding
+        return if previous
+
+        bindings[name] = binding
+        record[:service_templates] << binding
+      end
+
       attr_reader :data
 
       # 初始化无线实体集合及配置诊断。
       def initialize
+        @entity_names = Hash.new { |hash, kind| hash[kind] = {} }
+        @template_bindings = {}.compare_by_identity
         @data = { access_points: {}, ap_groups: [], service_templates: [], global_settings: {}, blacklist: [], whitelist: [] }
       end
 
       # 使用实体集合作为身份索引，首条重复记录仅供部分结果保留。
       def entity(kind, name, model: nil, type: nil)
         collection = data.fetch(kind)
-        duplicate = kind == :access_points ? collection.key?(name) : collection.any? { |record| record[:name] == name }
+        duplicate = @entity_names[kind].key?(name)
         raise ArgumentError, "Duplicate wireless configuration identity" if duplicate
 
+        @entity_names[kind][name] = true
         record = case kind
         when :ap_groups
           { name: name, ap_names: [], serial_ids: [], vlan_ids: [], model_profiles: {}, configuration: type ? { type: type } : {} }

data/lib/wireless/h3c/document.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "ctx_parser/document"
+require "ctx_parser/banner"
+require_relative "../terminal"
+
+module Wireless
+  module H3c
+    # 横幅仅含文本；分页及终端控制残留使配置证据不完整。
+    class Document < CtxParser::Document
+      protected
+
+      # 先隔离横幅，再分类影响完整性的终端残留。
+      def classify(line)
+        @banner ||= CtxParser::Banner.new
+        return :ignored if @banner.consume(line.text)
+
+        if Terminal.invalid_output?(line.raw)
+          issues << { code: :incomplete_configuration, line: line.number }
+          return :ignored
+        end
+        super
+      end
+
+      # 未闭合横幅不能成为完整配置证据。
+      def finish
+        issues.each { |issue| cursor.mark(issue.fetch(:line) - 1, state: :invalid) }
+        issues << { code: :incomplete_banner } if @banner&.open?
+      end
+    end
+  end
+end