breadkit-lint 0.1.0 → 0.2.0

data/lib/breadkit/lint/rules/intent.rb

@@ -7,19 +7,33 @@ module Breadkit
         circuit.nets(state).filter_map do |net|
           next unless net.labels.length > 1
           message = translate("label_conflict", "net has conflicting labels: #{net.labels.join(', ')}", labels: net.labels.join(", "))
-          offense(rule.id, message, nil, targets: { nets: [net.name] }, state: state.name)
+          location = circuit.labels.find { |label| net.labels.include?(label.name) }&.location
+          offense(rule.id, message, location, targets: { nets: [net.name] }, state: state.name)
         end
       end
 
       def expectations(circuit, rule, state)
         return [] if rule.id == "Intent/UnknownNet" && circuit.diagnostics.any? { |item| item.code == "unknown_net" }
         circuit.expectations.flat_map do |expectation|
+          at_state = expectation["when"] || expectation[:when]
+          if at_state
+            unless @config.intent_states(circuit, [expectation]).any? { |candidate| candidate.name == at_state }
+              next [] unless state.name.nil? && rule.id == "Intent/ConnectionMismatch"
+              next [offense(rule.id, translate("unknown_state", "unknown circuit state #{at_state}", state: at_state),
+                            location_from(expectation["location"] || expectation[:location]), targets: {})]
+            end
+            next [] unless state.name == at_state
+          else
+            next [] unless state.name.nil?
+          end
           strict = expectation["strict"] || expectation[:strict]
-          Array(expectation["entries"] || expectation[:entries]).filter_map do |item|
+          entries = Array(expectation["entries"] || expectation[:entries])
+          results = entries.filter_map do |item|
             kind = item["kind"] || item[:kind]
             refs = item["refs"] || item[:refs] || []
             expected_name = item["name"] || item[:name]
             loc = item["location"] || item[:location]
+            next measured_expectation(circuit, rule, state, item) if %w[voltage current].include?(kind)
             names = refs.map(&:to_s)
             nets = names.empty? && kind == "net" ? [circuit.net_of(expected_name, state)] : names.map { |reference| circuit.net_of(reference, state) }
             if nets.any?(&:nil?)
@@ -38,20 +52,71 @@ module Breadkit
                 circuit.components.keys.any? { |ref| member.start_with?("#{ref}.") }
               end.uniq
               declared_pins = names.map { |name| canonical_pin(circuit, name) }
-              extra_pins = strict ? actual_pins - declared_pins : []
+              extra_pins = strict ? (actual_pins - declared_pins).sort : []
               name_matches = nets.first.name == expected_name.to_s
               next if nets.map(&:name).uniq.length == 1 && extra_pins.empty? && name_matches
               detail = if !extra_pins.empty?
                 translate("undeclared_pins", "undeclared pins on expected net: #{extra_pins.join(', ')}", pins: extra_pins.join(", "))
               elsif !name_matches
-                translate("expected_net_name", "expected net #{expected_name}, found #{nets.first.name}", expected: expected_name, actual: nets.first.name)
+                translate("expected_net_name", "expected net #{expected_name}, found #{nets.first.name}; add net :#{expected_name}, at: ... to label it", expected: expected_name, actual: nets.first.name)
               else
                 translate("expected_one_net", "expected #{names.join(', ')} on one net", refs: names.join(", "))
               end
               offense(rule.id, detail, location_from(loc), targets: { nets: nets.compact.map(&:name), components: extra_pins.map { |pin| pin.split('.', 2).first } }, state: state.name)
             end
           end
+          if strict && rule.id == "Intent/ConnectionMismatch"
+            declared_names = entries.select { |item| (item["kind"] || item[:kind]) == "net" }.flat_map do |item|
+              Array(item["refs"] || item[:refs]).filter_map { |ref| circuit.net_of(ref, state)&.name }
+            end.uniq
+            outside_nets = circuit.nets(state).filter_map do |net|
+              next if declared_names.include?(net.name)
+              pins = net.members.select { |member| circuit.components.key?(member.split(".", 2).first) }.sort
+              next if pins.empty?
+              [net, pins]
+            end
+            outside_nets.sort_by { |_net, pins| pins.first }.each do |net, pins|
+              message = translate("undeclared_pins", "undeclared pins outside expected nets: #{pins.join(', ')}", pins: pins.join(", "))
+              first_net_entry = entries.find { |item| (item["kind"] || item[:kind]) == "net" }
+              location = first_net_entry && (first_net_entry["location"] || first_net_entry[:location])
+              results << offense(rule.id, message, location_from(location || expectation["location"] || expectation[:location]),
+                                 targets: { nets: [net.name], components: pins.map { |pin| pin.split(".", 2).first }.uniq,
+                                            pins: pins }, state: state.name)
+            end
+          end
+          results
+        end
+      end
+
+      def measured_expectation(circuit, rule, state, item)
+        return unless %w[Intent/ConnectionMismatch Intent/MeasurementUnavailable].include?(rule.id)
+
+        kind = item["kind"] || item[:kind]
+        reference = Array(item["refs"] || item[:refs]).first.to_s
+        range = item["range"] || item[:range]
+        location = location_from(item["location"] || item[:location])
+        analysis = circuit.dc_analysis(state)
+        if analysis.success?
+          net = circuit.net_of(reference, state) if kind == "voltage"
+          value = kind == "voltage" ? analysis.voltages[net&.name] : analysis.currents[reference]&.abs
+          floating = kind == "voltage" && analysis.floating.any? { |group| group.include?(net&.name) }
+          reason = "no grounded DC value" if value.nil? || floating
+        else
+          reason = analysis.errors.join("; ")
         end
+        if reason
+          return unless rule.id == "Intent/MeasurementUnavailable"
+
+          message = translate("measurement_unavailable", "cannot verify #{kind} at #{reference}: #{reason}",
+                              kind: kind, ref: reference, reason: reason)
+          return offense(rule.id, message, location, state: state.name)
+        end
+        return unless rule.id == "Intent/ConnectionMismatch" && (value < range[0] - 1e-9 || value > range[1] + 1e-9)
+
+        unit = kind == "voltage" ? "V" : "A"
+        message = translate("measurement_mismatch", "expected #{reference} #{kind} #{range.join('..')} #{unit}, found #{format('%.6g', value)} #{unit}",
+                            ref: reference, kind: kind, range: range.join(".."), value: format("%.6g", value), unit: unit)
+        offense(rule.id, message, location, state: state.name)
       end
 
     end

data/lib/breadkit/lint/rules/layout.rb

@@ -28,6 +28,154 @@ module Breadkit
         end
       end
 
+      def hole_covered(circuit, rule, _state)
+        circuit.components.values.flat_map do |owner|
+          bounds = body_rectangle(owner, circuit.board)
+          next [] unless bounds
+          left, top, width, height = bounds
+          inside = lambda do |hole|
+            hole && hole.x > left + 1e-6 && hole.x < left + width - 1e-6 &&
+              hole.y > top + 1e-6 && hole.y < top + height - 1e-6
+          end
+          leads = circuit.components.values.reject { |component| component.equal?(owner) }.flat_map do |component|
+            component.pins.values.filter_map do |pin|
+              hole = pin.hole_id && circuit.board.hole(pin.hole_id)
+              next unless inside.call(hole)
+              reference = "#{component.ref}.#{pin.name}"
+              offense(rule.id, translate("hole_covered_lead", "#{reference} is under #{owner.ref} at #{hole.id}",
+                                         pin: reference, module: owner.ref, hole: hole.id), component.location,
+                      targets: { components: [owner.ref, component.ref], pins: [reference], holes: [hole.id] })
+            end
+          end
+          wires = circuit.wires.flat_map do |wire|
+            next [] if wire.electrical == false
+            [wire.from, wire.to].uniq.filter_map do |endpoint|
+              hole = circuit.board.hole(endpoint)
+              next unless inside.call(hole)
+              offense(rule.id, translate("hole_covered_wire", "#{wire.id} ends under #{owner.ref} at #{hole.id}",
+                                         wire: wire.id, module: owner.ref, hole: hole.id), wire.location,
+                      targets: { components: [owner.ref], wires: [wire.id], holes: [hole.id] })
+            end
+          end
+          leads + wires
+        end
+      end
+
+      def body_overlap(circuit, rule, _state)
+        bodies = circuit.components.values.filter_map do |component|
+          body = physical_body(component, circuit.board)
+          [component, body] if body
+        end
+        bodies.combination(2).filter_map do |(first, a), (second, b)|
+          next unless bodies_overlap?(a, b)
+          offense(rule.id, translate("body_overlap", "#{first.ref} and #{second.ref} bodies overlap",
+                                     first: first.ref, second: second.ref), second.location,
+                  targets: { components: [first.ref, second.ref] })
+        end
+      end
+
+      def wire_over_ic(circuit, rule, _state)
+        circuit.components.values.flat_map do |component|
+          bounds = dip_body_bounds(component, circuit.board)
+          next [] unless bounds
+          circuit.wires.filter_map do |wire|
+            next unless wire.electrical != false && wire.route == "straight"
+            from = circuit.board.hole(wire.from)
+            to = circuit.board.hole(wire.to)
+            next unless from && to
+            next unless segment_crosses_rect?(from, to, bounds)
+            offense(rule.id, translate("wire_over_ic", "#{wire.id} crosses #{component.ref} body",
+                                       wire: wire.id, ic: component.ref), wire.location,
+                    targets: { components: [component.ref], wires: [wire.id] })
+          end
+        end
+      end
+
+      def lead_span(circuit, rule, _state)
+        circuit.components.values.filter_map do |component|
+          part = component.part
+          next unless part.respond_to?(:max_lead_span_mm)
+          limit = part.max_lead_span_mm
+          next unless limit
+          pins = component.pins.values
+          next unless pins.length == 2
+          holes = pins.map { |pin| pin.hole_id && circuit.board.hole(pin.hole_id) }
+          next unless holes.all?
+          actual = Math.hypot(holes[0].x - holes[1].x, holes[0].y - holes[1].y) * 2.54
+          next unless actual > limit + 1e-6
+          actual_text, limit_text = format("%.3f", actual), format("%.3f", limit)
+          offense(rule.id, translate("lead_span", "#{component.ref} spans #{actual_text} mm; limit is #{limit_text} mm",
+                                     ref: component.ref, actual: actual_text, limit: limit_text),
+                  component.location,
+                  targets: { components: [component.ref], pins: pins.map { |pin| "#{component.ref}.#{pin.name}" }, holes: holes.map(&:id) })
+        end
+      end
+
+      def dip_body_bounds(component, board)
+        return unless component.part.placement == "dip" && component.part.data.dig("render", "shape") == "dip"
+        holes = component.pins.values.filter_map { |pin| board.hole(pin.hole_id) if pin.hole_id }
+        return unless holes.length == component.part.pins.length && holes.all? { |hole| hole.kind == :terminal }
+        xs, ys = holes.map(&:x), holes.map(&:y).uniq.sort
+        return unless ys.length == 2 && (ys.last - ys.first - 3).abs < 1e-6
+        rows = holes.group_by(&:y).values.map { |row| row.map(&:x).sort }
+        return unless rows[0] == rows[1] && rows[0].length * 2 == holes.length
+        [xs.min - 0.4, (ys.first + ys.last) / 2.0 - 0.4, xs.max - xs.min + 0.8, 0.8]
+      end
+
+      def segment_crosses_rect?(from, to, bounds)
+        left, top, width, height = bounds
+        ranges = [[left + 1e-6, left + width - 1e-6, from.x, to.x],
+                  [top + 1e-6, top + height - 1e-6, from.y, to.y]]
+        entry, exit = 0.0, 1.0
+        ranges.each do |minimum, maximum, start, finish|
+          delta = finish - start
+          return false if delta.abs < 1e-9 && !(start > minimum && start < maximum)
+          next if delta.abs < 1e-9
+          first, last = [(minimum - start) / delta, (maximum - start) / delta].minmax
+          entry = [entry, first].max
+          exit = [exit, last].min
+        end
+        entry < exit - 1e-9
+      end
+
+      def physical_body(component, board)
+        shape = component.part.data.dig("render", "shape")
+        if %w[module dip].include?(shape)
+          bounds = body_rectangle(component, board)
+          return [:rect, *bounds] if bounds
+        elsif %w[led_5mm rgb_led_5mm].include?(shape)
+          holes = component.pins.values.filter_map { |pin| board.hole(pin.hole_id) if pin.hole_id }
+          return unless holes.length == component.pins.length && !holes.empty?
+          return [:circle, holes.sum(&:x) / holes.length, holes.sum(&:y) / holes.length, 2.5 / 2.54]
+        end
+        nil
+      end
+
+      def body_rectangle(component, board)
+        shape = component.part.data.dig("render", "shape")
+        return component.body_bounds(board) if shape == "module" && component.respond_to?(:body_bounds)
+        dip_body_bounds(component, board) if shape == "dip"
+      end
+
+      def bodies_overlap?(a, b)
+        if a.first == :rect && b.first == :rect
+          _kind, ax, ay, aw, ah = a
+          _kind, bx, by, bw, bh = b
+          return ax < bx + bw - 1e-6 && bx < ax + aw - 1e-6 &&
+                 ay < by + bh - 1e-6 && by < ay + ah - 1e-6
+        end
+        if a.first == :circle && b.first == :circle
+          dx, dy = a[1] - b[1], a[2] - b[2]
+          return dx * dx + dy * dy < (a[3] + b[3] - 1e-6)**2
+        end
+        circle, rect = a.first == :circle ? [a, b] : [b, a]
+        _kind, cx, cy, radius = circle
+        _kind, rx, ry, width, height = rect
+        dx = cx - cx.clamp(rx, rx + width)
+        dy = cy - cy.clamp(ry, ry + height)
+        dx * dx + dy * dy < (radius - 1e-6)**2
+      end
+
     end
   end
 end

data/lib/breadkit/lint/rules/style.rb

@@ -10,7 +10,8 @@ module Breadkit
           net = circuit.nets.find { |item| item.members.include?(wire.id) }
           voltage = net && circuit.potentials.values[net.name]
           expected = voltage&.positive? ? positive : (voltage == 0.0 ? ground : nil)
-          next unless expected && wire.color && !expected.include?(color_family(wire.color))
+          family = color_family(wire.color) if wire.color
+          next unless expected && family && !expected.include?(family)
           message = translate("wire_color", "#{wire.id} uses #{wire.color}; expected #{expected.join(' or ')}",
                               wire: wire.id, color: wire.color, expected: expected.join(" / "))
           offense(rule.id, message, wire.location,
@@ -20,10 +21,36 @@ module Breadkit
 
       def color_family(color)
         value = color.to_s.downcase
-        return value unless value.match?(/\A#(?:[0-9a-f]{3}|[0-9a-f]{6})\z/)
-        digits = value.delete_prefix("#")
-        digits = digits.chars.map { |digit| digit * 2 }.join if digits.length == 3
-        red, green, blue = digits.scan(/../).map { |pair| pair.to_i(16) }
+        return "gray" if value.match?(/gr[ae]y|silver|white/)
+        return "black" if value == "black"
+        return "red" if value.match?(/red|crimson|maroon|firebrick|coral|tomato/)
+        return "orange" if value.match?(/orange|gold|salmon/)
+        return "blue" if value.match?(/blue|navy|azure|cyan|teal|turquoise/)
+        return "green" if value.match?(/green|lime|chartreuse|olive|spring|aquamarine/)
+        return "yellow" if value.match?(/yellow|khaki/)
+        return "purple" if value.match?(/purple|violet|indigo|orchid|plum|magenta|fuchsia/)
+        return "pink" if value.match?(/pink|lavender/)
+        return "brown" if value.match?(/brown|tan|chocolate|peru|sienna|wheat/)
+        if (match = /\Ahsl\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)\z/.match(value))
+          hue, saturation, lightness = match.captures.map(&:to_i)
+          return "black" if lightness <= 15
+          return "gray" if saturation < 25
+          return "red" if hue < 15 || hue >= 345
+          return "orange" if hue < 50
+          return "yellow" if hue < 75
+          return "green" if hue < 165
+          return "blue" if hue.between?(165, 255)
+          return "purple"
+        end
+        if (match = /\Argb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)\z/.match(value))
+          red, green, blue = match.captures.map(&:to_i)
+        elsif value.match?(/\A#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})\z/)
+          digits = value.delete_prefix("#")
+          digits = digits.chars.map { |digit| digit * 2 }.join if digits.length <= 4
+          red, green, blue = digits.scan(/../).first(3).map { |pair| pair.to_i(16) }
+        else
+          return nil
+        end
         max, min = [red, green, blue].max, [red, green, blue].min
         return "black" if max <= 76
         return "gray" if max == min || (max - min).fdiv(max) < 0.25
@@ -34,8 +61,10 @@ module Breadkit
         end % 360
         return "red" if hue < 15 || hue >= 345
         return "orange" if hue < 50
-        return "blue" if hue.between?(195, 255)
-        value
+        return "yellow" if hue < 75
+        return "green" if hue < 165
+        return "blue" if hue.between?(165, 255)
+        "purple"
       end
 
     end

data/lib/breadkit/lint/rules/support.rb

@@ -22,18 +22,30 @@ module Breadkit
 
       def diagnostic_targets(circuit, values)
         ids = { components: circuit.components.keys, wires: circuit.wires.map(&:id),
-                holes: circuit.board.holes.keys, nets: circuit.nets.map(&:name) }
+                holes: circuit.board.holes.keys,
+                pins: circuit.components.values.flat_map { |component| component.pins.values.map { |pin| "#{component.ref}.#{pin.name}" } },
+                nets: circuit.nets.map(&:name) }
         Array(values).each_with_object({}) do |value, targets|
-          kind = ids.find { |_type, known| known.include?(value) }&.first
-          (targets[kind] ||= []) << value if kind
+          canonical = canonical_pin(circuit, value)
+          kind = ids.find { |_type, known| known.include?(canonical) }&.first
+          (targets[kind] ||= []) << canonical if kind
         end
       end
 
       def diagnostic_message(diagnostic)
         target = Array(diagnostic.targets).join(", ")
         target = diagnostic.message[/unknown pin ([^;]+)/, 1] || target if diagnostic.code == "unknown_pin"
+        target = diagnostic.message[/unknown board: (.+)/, 1] || target if diagnostic.code == "unknown_board"
         option = diagnostic.message[/unknown component option ([^ ]+)/, 1] if diagnostic.code == "unknown_option"
-        translate("diagnostic_#{diagnostic.code}", diagnostic.message, target: target, option: option)
+        reason = case diagnostic.message
+        when /must straddle the center gap/ then translate("placement_straddle", "must straddle the center gap")
+        when /extends beyond the board or into the center gap/ then translate("placement_bounds_or_gap", "extends beyond the board or into the center gap")
+        when /extends beyond the board/ then translate("placement_bounds", "extends beyond the board")
+        when /pins do not match its footprint/ then translate("placement_footprint", "pins do not match the footprint")
+        when /needs a terminal hole anchor/ then translate("placement_anchor", "needs a terminal hole anchor")
+        else diagnostic.message
+        end
+        translate("diagnostic_#{diagnostic.code}", diagnostic.message, target: target, option: option, reason: reason)
       end
 
       def translate(key, english, **values)
@@ -41,35 +53,57 @@ module Breadkit
         template ? format(template, **values) : english
       end
 
-      def offense(rule_id, message, location, targets: {}, state: nil)
+      def offense(rule_id, message, location, targets: {}, state: nil, suggestion: nil)
         rule = Registry.all.find { |item| item.id == rule_id }
         Offense.new(rule: rule_id, severity: rule ? @config.severity(rule) : "error", message: message,
-                    location: location, targets: targets, state: state)
+                    location: location, targets: targets, state: state, suggestion: suggestion)
       end
 
-      def suppress(offenses, disables, circuit)
+      def suppress(offenses, disables, circuit, path:, only: nil, except: nil, skipped: false)
         invalid_disables = []
         invalid = disables.filter_map do |disable|
           rule_id = disable[:rule] || disable["rule"]
           reason = disable[:reason] || disable["reason"]
-          message = if Registry.all.none? { |rule| rule.id == rule_id }
+          unknown = Registry.all.none? { |rule| rule.id == rule_id }
+          message = if unknown
             translate("unknown_disable", "unknown rule in lint_disable: #{rule_id}", rule: rule_id)
           elsif @config.data.dig("AllRules", "RequireDisableReason") && reason.to_s.strip.empty?
             translate("disable_reason", "lint_disable for #{rule_id} requires a reason", rule: rule_id)
           end
           next unless message
           invalid_disables << disable
-          offense("Config/InvalidDisable", message, location_from(disable[:location] || disable["location"]))
+          if unknown
+            rule = Rules::Lint::UnknownRuleInDisable
+            next if !@config.enabled?(rule) || !@config.rule_applies?(rule, path) || (only && !only.include?(rule.id)) || except&.include?(rule.id)
+          end
+          offense(unknown ? "Lint/UnknownRuleInDisable" : "Config/InvalidDisable", message,
+                  location_from(disable[:location] || disable["location"]))
         end
         valid = disables - invalid_disables
+        used = []
         kept = offenses.reject do |item|
-          valid.any? do |disable|
+          match = valid.find do |disable|
             rule = disable[:rule] || disable["rule"]
             target = disable[:on] || disable["on"]
             rule == item.rule && (!target || item.targets.values.flatten.include?(canonical_pin(circuit, target)))
           end
+          used << match if match
+          !!match
+        end
+        redundant_selected = (!only || only.include?("Lint/RedundantDisable")) && !except&.include?("Lint/RedundantDisable")
+        redundant = valid.filter_map do |disable|
+          next unless redundant_selected
+          rule_id = disable[:rule] || disable["rule"]
+          rule = Registry.all.find { |item| item.id == rule_id }
+          next if used.include?(disable) || !rule || !@config.enabled?(rule) || !@config.rule_applies?(rule, path)
+          next if only && !only.include?(rule_id)
+          next if except&.include?(rule_id)
+          next if skipped && rule_id.start_with?("Electrical/", "Intent/")
+          next unless @config.enabled?(Rules::Lint::RedundantDisable) && @config.rule_applies?(Rules::Lint::RedundantDisable, path)
+          offense("Lint/RedundantDisable", translate("redundant_disable", "lint_disable for #{rule_id} suppresses no offense", rule: rule_id),
+                  location_from(disable[:location] || disable["location"]))
         end
-        kept + invalid
+        (kept + invalid + redundant).sort_by { |item| [item.location&.path.to_s, item.location&.line.to_i, item.rule, item.message] }
       end
 
       def canonical_pin(circuit, reference)